pangolindex / exchange-contracts Goto Github PK

i have found some thing in your smart contract. Where i need to contact you?.

Hi, I'm curious if I can see the PGL deposit contract or an interface for it?

What are the addresses for router and factory on the Fuji testnet? Im unsure where to find the addresses.

Just add a non zero address require :

​// File: contracts/Factory.sol

​pragma solidity​ ​^​0.4.15​;

​contract​ ​Factory​ {

​    ​/*
​     *  Events
​     */
​    ​event ​ContractInstantiation​(​address​ ​sender​, ​address​ ​instantiation​);

​    ​/*
​     *  Storage
​     */
​    ​mapping​(​address​ ​=>​ ​bool​) ​public​ isInstantiation;
​    ​mapping​(​address​ ​=>​ ​address​[]) ​public​ instantiations;

​    ​/*
​     * Public functions
​     */
​    ​/// @dev Returns number of instantiations by creator.
​    ​/// @param creator Contract creator.
​    ​/// @return Returns number of instantiations by creator.
​    ​function​ getInstantiationCount​(​address​ ​creator​)
​        ​public
​        ​constant
​        ​returns​ (​uint​)
​    {
​        ​return​ instantiations[creator].length;
​    }

​    ​/*
​     * Internal functions
​     */
​    ​/// @dev Registers contract in factory registry.
​    ​/// @param instantiation Address of contract instantiation.
​    ​function​ register​(​address​ ​instantiation​)
​        ​internal
​    {
​        isInstantiation[instantiation] ​=​ ​true​;
​        instantiations[​msg​.​sender​].​push​(instantiation);
​        ​ContractInstantiation​(​msg​.​sender​, instantiation);
​    }
​}

​// File: contracts/MultiSigWallet.sol

​pragma solidity​ ​^​0.4.15​;

​/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
​/// @author Stefan George - [email protected]
​contract​ ​MultiSigWallet​ {

​    ​/*
​     *  Events
​     */
​    ​event ​Confirmation​(​address​ ​indexed​ ​sender​, ​uint​ ​indexed​ ​transactionId​);
​    ​event ​Revocation​(​address​ ​indexed​ ​sender​, ​uint​ ​indexed​ ​transactionId​);
​    ​event ​Submission​(​uint​ ​indexed​ ​transactionId​);
​    ​event ​Execution​(​uint​ ​indexed​ ​transactionId​);
​    ​event ​ExecutionFailure​(​uint​ ​indexed​ ​transactionId​);
​    ​event ​Deposit​(​address​ ​indexed​ ​sender​, ​uint​ ​value​);
​    ​event ​OwnerAddition​(​address​ ​indexed​ ​owner​);
​    ​event ​OwnerRemoval​(​address​ ​indexed​ ​owner​);
​    ​event ​RequirementChange​(​uint​ ​required​);

​    ​/*
​     *  Constants
​     */
​    ​uint​ ​constant public ​MAX_OWNER_COUNT ​=​ ​50​;

​    ​/*
​     *  Storage
​     */
​    ​mapping​ (​uint​ ​=>​ Transaction) ​public​ transactions;
​    ​mapping​ (​uint​ ​=>​ ​mapping​ (​address​ ​=>​ ​bool​)) ​public​ confirmations;
​    ​mapping​ (​address​ ​=>​ ​bool​) ​public​ isOwner;
​    ​address​[] ​public​ owners;
​    ​uint​ ​public​ required;
​    ​uint​ ​public​ transactionCount;

​    ​struct​ Transaction​ {
​        ​address​ destination;
​        ​uint​ value;
​        ​bytes​ data;
​        ​bool​ executed;
​    }

​    ​/*
​     *  Modifiers
​     */
​    ​modifier​ onlyWallet​() {
​        ​require​(​msg​.​sender​ ​==​ ​address​(​this​));
​        ​_;
​    }

​    ​modifier​ ownerDoesNotExist​(​address​ ​owner​) {
​        ​require​(​!​isOwner[owner]);
​        ​_;
​    }

​    ​modifier​ ownerExists​(​address​ ​owner​) {
​        ​require​(isOwner[owner]);
​        ​_;
​    }

​    ​modifier​ transactionExists​(​uint​ ​transactionId​) {
​        ​require​(transactions[transactionId].destination ​!=​ ​0​);
​        ​_;
​    }

​    ​modifier​ confirmed​(​uint​ ​transactionId​, ​address​ ​owner​) {
​        ​require​(confirmations[transactionId][owner]);
​        ​_;
​    }

​    ​modifier​ notConfirmed​(​uint​ ​transactionId​, ​address​ ​owner​) {
​        ​require​(​!​confirmations[transactionId][owner]);
​        ​_;
​    }

​    ​modifier​ notExecuted​(​uint​ ​transactionId​) {
​        ​require​(​!​transactions[transactionId].executed);
​        ​_;
​    }

​    ​modifier​ notNull​(​address​ ​_address​) {
​        ​require​(address ​!=​ ​0​);
​        ​;
​    }

​    ​modifier​ validRequirement​(​uint​ ​ownerCount​, ​uint​ ​_required​) {
​        ​require​(ownerCount ​<=​ MAX_OWNER_COUNT
​            ​&&​ _required ​<=​ ownerCount
​            ​&&​ required ​!=​ ​0
​            ​&&​ ownerCount ​!=​ ​0​);
​        ​;
​    }

​    ​/// @dev Fallback function allows to deposit ether.
​    ​function​()
​        ​payable
​    {
​        ​if​ (​msg​.​value​ ​>​ ​0​)
​            ​Deposit​(​msg​.​sender​, ​msg​.​value​);
​    }

​    ​/*
​     * Public functions
​     */
​    ​/// @dev Contract constructor sets initial owners and required number of confirmations.
​    ​/// @param _owners List of initial owners.
​    ​/// @param _required Number of required confirmations.
​    ​function​ MultiSigWallet​(​address​[] ​_owners​, ​uint​ ​_required​)
​        ​public
​        ​validRequirement​(_owners.length, _required)
​    {
​        ​for​ (​uint​ i​=​0​; i​<​_owners.length; i​++​) {
​            ​require​(​!​isOwner[_owners[i]] ​&&​ _owners[i] ​!=​ ​0​);
​            isOwner[_owners[i]] ​=​ ​true​;
​        }
​        owners ​=​ _owners;
​        required ​=​ _required;
​    }

​    ​/// @dev Allows to add a new owner. Transaction has to be sent by wallet.
​    ​/// @param owner Address of new owner.
​    ​function​ addOwner​(​address​ ​owner​)
​        ​public
​        onlyWallet
​        ​ownerDoesNotExist​(owner)
​        ​notNull​(owner)
​        ​validRequirement​(owners.length ​+​ ​1​, required)
​    {
​        isOwner[owner] ​=​ ​true​;
​        owners.​push​(owner);
​        ​OwnerAddition​(owner);
​    }

​    ​/// @dev Allows to remove an owner. Transaction has to be sent by wallet.
​    ​/// @param owner Address of owner.
​    ​function​ removeOwner​(​address​ ​owner​)
​        ​public
​        onlyWallet
​        ​ownerExists​(owner)
​    {
​        isOwner[owner] ​=​ ​false​;
​        ​for​ (​uint​ i​=​0​; i​<​owners.length ​-​ ​1​; i​++​)
​            ​if​ (owners[i] ​==​ owner) {
​                owners[i] ​=​ owners[owners.length ​-​ ​1​];
​                ​break​;
​            }
​        owners.length ​-=​ ​1​;
​        ​if​ (required ​>​ owners.length)
​            ​changeRequirement​(owners.length);
​        ​OwnerRemoval​(owner);
​    }

​    ​/// @dev Allows to replace an owner with a new owner. Transaction has to be sent by wallet.
​    ​/// @param owner Address of owner to be replaced.
​    ​/// @param newOwner Address of new owner.
​    ​function​ replaceOwner​(​address​ ​owner​, ​address​ ​newOwner​)
​        ​public
​        onlyWallet
​        ​ownerExists​(owner)
​        ​ownerDoesNotExist​(newOwner)
​    {
​        ​for​ (​uint​ i​=​0​; i​<​owners.length; i​++​)
​            ​if​ (owners[i] ​==​ owner) {
​                owners[i] ​=​ newOwner;
​                ​break​;
​            }
​        isOwner[owner] ​=​ ​false​;
​        isOwner[newOwner] ​=​ ​true​;
​        ​OwnerRemoval​(owner);
​        ​OwnerAddition​(newOwner);
​    }

​    ​/// @dev Allows to change the number of required confirmations. Transaction has to be sent by wallet.
​    ​/// @param _required Number of required confirmations.
​    ​function​ changeRequirement​(​uint​ ​_required​)
​        ​public
​        onlyWallet
​        ​validRequirement​(owners.length, _required)
​    {
​        required ​=​ _required;
​        ​RequirementChange​(_required);
​    }

​    ​/// @dev Allows an owner to submit and confirm a transaction.
​    ​/// @param destination Transaction target address.
​    ​/// @param value Transaction ether value.
​    ​/// @param data Transaction data payload.
​    ​/// @return Returns transaction ID.
​    ​function​ submitTransaction​(​address​ ​destination​, ​uint​ ​value​, ​bytes​ ​data​)
​        ​public
​        ​returns​ (​uint​ ​transactionId​)
​    {
​        transactionId ​=​ ​addTransaction​(destination, value, data);
​        ​confirmTransaction​(transactionId);
​    }

​    ​/// @dev Allows an owner to confirm a transaction.
​    ​/// @param transactionId Transaction ID.
​    ​function​ confirmTransaction​(​uint​ ​transactionId​)
​        ​public
​        ​ownerExists​(​msg​.​sender​)
​        ​transactionExists​(transactionId)
​        ​notConfirmed​(transactionId, ​msg​.​sender​)
​    {
​        confirmations[transactionId][​msg​.​sender​] ​=​ ​true​;
​        ​Confirmation​(​msg​.​sender​, transactionId);
​        ​executeTransaction​(transactionId);
​    }

​    ​/// @dev Allows an owner to revoke a confirmation for a transaction.
​    ​/// @param transactionId Transaction ID.
​    ​function​ revokeConfirmation​(​uint​ ​transactionId​)
​        ​public
​        ​ownerExists​(​msg​.​sender​)
​        ​confirmed​(transactionId, ​msg​.​sender​)
​        ​notExecuted​(transactionId)
​    {
​        confirmations[transactionId][​msg​.​sender​] ​=​ ​false​;
​        ​Revocation​(​msg​.​sender​, transactionId);
​    }

​    ​/// @dev Allows anyone to execute a confirmed transaction.
​    ​/// @param transactionId Transaction ID.
​    ​function​ executeTransaction​(​uint​ ​transactionId​)
​        ​public
​        ​ownerExists​(​msg​.​sender​)
​        ​confirmed​(transactionId, ​msg​.​sender​)
​        ​notExecuted​(transactionId)
​    {
​        ​if​ (​isConfirmed​(transactionId)) {
​            Transaction ​storage​ txn ​=​ transactions[transactionId];
​            txn.executed ​=​ ​true​;
​            ​if​ (​external_call​(txn.destination, txn.value, txn.data.length, txn.data))
​                ​Execution​(transactionId);
​            ​else​ {
​                ​ExecutionFailure​(transactionId);
​                txn.executed ​=​ ​false​;
​            }
​        }
​    }

​    ​// call has been separated into its own function in order to take advantage
​    ​// of the Solidity's code generator to produce a loop that copies tx.data into memory.
​    ​function​ external_call​(​address​ ​destination​, ​uint​ ​value​, ​uint​ ​dataLength​, ​bytes​ ​data​) ​internal​ ​returns​ (​bool​) {
​        ​bool​ result;
​        ​assembly​ {
​            ​let​ x ​:=​ ​mload​(​0x40​)   ​// "Allocate" memory for output (0x40 is where "free memory" pointer is stored by convention)
​            ​let​ d ​:=​ ​add​(data, ​32​) ​// First 32 bytes are the padded length of data, so exclude that
​            result ​:=​ ​call​(
​                ​sub​(gas, ​34710​),   ​// 34710 is the value that solidity is currently emitting
​                                   ​// It includes callGas (700) + callVeryLow (3, to pay for SUB) + callValueTransferGas (9000) +
​                                   ​// callNewAccountGas (25000, in case the destination address does not exist and needs creating)
​                destination,
​                value,
​                d,
​                dataLength,        ​// Size of the input (in bytes) - this is what fixes the padding problem
​                x,
​                ​0​                  ​// Output is ignored, therefore the output size is zero
​            )
​        }
​        ​return​ result;
​    }

​    ​/// @dev Returns the confirmation status of a transaction.
​    ​/// @param transactionId Transaction ID.
​    ​/// @return Confirmation status.
​    ​function​ isConfirmed​(​uint​ ​transactionId​)
​        ​public
​        ​constant
​        ​returns​ (​bool​)
​    {
​        ​uint​ count ​=​ ​0​;
​        ​for​ (​uint​ i​=​0​; i​<​owners.length; i​++​) {
​            ​if​ (confirmations[transactionId][owners[i]])
​                count ​+=​ ​1​;
​            ​if​ (count ​==​ required)
​                ​return​ ​true​;
​        }
​    }

​    ​/*
​     * Internal functions
​     */
​    ​/// @dev Adds a new transaction to the transaction mapping, if transaction does not exist yet.
​    ​/// @param destination Transaction target address.
​    ​/// @param value Transaction ether value.
​    ​/// @param data Transaction data payload.
​    ​/// @return Returns transaction ID.
​    ​function​ addTransaction​(​address​ ​destination​, ​uint​ ​value​, ​bytes​ ​data​)
​        ​internal
​        ​notNull​(destination)
​        ​returns​ (​uint​ ​transactionId​)
​    {
​        transactionId ​=​ transactionCount;
​        transactions[transactionId] ​=​ ​Transaction​({
​            destination: destination,
​            value: value,
​            data: data,
​            executed: ​false
​        });
​        transactionCount ​+=​ ​1​;
​        ​Submission​(transactionId);
​    }

​    ​/*
​     * Web3 call functions
​     */
​    ​/// @dev Returns number of confirmations of a transaction.
​    ​/// @param transactionId Transaction ID.
​    ​/// @return Number of confirmations.
​    ​function​ getConfirmationCount​(​uint​ ​transactionId​)
​        ​public
​        ​constant
​        ​returns​ (​uint​ ​count​)
​    {
​        ​for​ (​uint​ i​=​0​; i​<​owners.length; i​++​)
​            ​if​ (confirmations[transactionId][owners[i]])
​                count ​+=​ ​1​;
​    }

​    ​/// @dev Returns total number of transactions after filers are applied.
​    ​/// @param pending Include pending transactions.
​    ​/// @param executed Include executed transactions.
​    ​/// @return Total number of transactions after filters are applied.
​    ​function​ getTransactionCount​(​bool​ ​pending​, ​bool​ ​executed​)
​        ​public
​        ​constant
​        ​returns​ (​uint​ ​count​)
​    {
​        ​for​ (​uint​ i​=​0​; i​<​transactionCount; i​++​)
​            ​if​ (   pending ​&&​ ​!​transactions[i].executed
​                ​||​ executed ​&&​ transactions[i].executed)
​                count ​+=​ ​1​;
​    }

​    ​/// @dev Returns list of owners.
​    ​/// @return List of owner addresses.
​    ​function​ getOwners​()
​        ​public
​        ​constant
​        ​returns​ (​address​[])
​    {
​        ​return​ owners;
​    }

​    ​/// @dev Returns array with owner addresses, which confirmed transaction.
​    ​/// @param transactionId Transaction ID.
​    ​/// @return Returns array of owner addresses.
​    ​function​ getConfirmations​(​uint​ ​transactionId​)
​        ​public
​        ​constant
​        ​returns​ (​address​[] ​_confirmations​)
​    {
​        ​address​[] ​memory ​confirmationsTemp ​=​ ​new​ ​address​;
​        ​uint​ count ​=​ ​0​;
​        ​uint​ i;
​        ​for​ (i​=​0​; i​<​owners.length; i​++​)
​            ​if​ (confirmations[transactionId][owners[i]]) {
​                confirmationsTemp[count] ​=​ owners[i];
​                count ​+=​ ​1​;
​            }
​        _confirmations ​=​ ​new​ ​address​;
​        ​for​ (i​=​0​; i​<​count; i​++​)
​            _confirmations[i] ​=​ confirmationsTemp[i];
​    }

​    ​/// @dev Returns list of transaction IDs in defined range.
​    ​/// @param from Index start position of transaction array.
​    ​/// @param to Index end position of transaction array.
​    ​/// @param pending Include pending transactions.
​    ​/// @param executed Include executed transactions.
​    ​/// @return Returns array of transaction IDs.
​    ​function​ getTransactionIds​(​uint​ ​from​, ​uint​ ​to​, ​bool​ ​pending​, ​bool​ ​executed​)
​        ​public
​        ​constant
​        ​returns​ (​uint​[] ​_transactionIds​)
​    {
​        ​uint​[] ​memory ​transactionIdsTemp ​=​ ​new​ ​uint​;
​        ​uint​ count ​=​ ​0​;
​        ​uint​ i;
​        ​for​ (i​=​0​; i​<​transactionCount; i​++​)
​            ​if​ (   pending ​&&​ ​!​transactions[i].executed
​                ​||​ executed ​&&​ transactions[i].executed)
​            {
​                transactionIdsTemp[count] ​=​ i;
​                count ​+=​ ​1​;
​            }
​        _transactionIds ​=​ ​new​ ​uint​;
​        ​for​ (i​=​from; i​<​to; i​++​)
​            _transactionIds[i ​-​ from] ​=​ transactionIdsTemp[i];
​    }
​}

​// File: contracts/MultiSigWalletWithDailyLimit.sol

​pragma solidity​ ​^​0.4.15​;

​/// @title Multisignature wallet with daily limit - Allows an owner to withdraw a daily limit without multisig.
​/// @author Stefan George - [email protected]
​contract​ ​MultiSigWalletWithDailyLimit​ ​is​ ​MultiSigWallet​ {

​    ​/*
​     *  Events
​     */
​    ​event ​DailyLimitChange​(​uint​ ​dailyLimit​);

​    ​/*
​     *  Storage
​     */
​    ​uint​ ​public​ dailyLimit;
​    ​uint​ ​public​ lastDay;
​    ​uint​ ​public​ spentToday;

​    ​/*
​     * Public functions
​     */
​    ​/// @dev Contract constructor sets initial owners, required number of confirmations and daily withdraw limit.
​    ​/// @param _owners List of initial owners.
​    ​/// @param _required Number of required confirmations.
​    ​/// @param _dailyLimit Amount in wei, which can be withdrawn without confirmations on a daily basis.
​    ​function​ MultiSigWalletWithDailyLimit​(​address​[] ​_owners​, ​uint​ ​_required​, ​uint​ ​_dailyLimit​)
​        ​public
​        ​MultiSigWallet​(_owners, _required)
​    {
​        dailyLimit ​=​ _dailyLimit;
​    }

​    ​/// @dev Allows to change the daily limit. Transaction has to be sent by wallet.
​    ​/// @param _dailyLimit Amount in wei.
​    ​function​ changeDailyLimit​(​uint​ ​_dailyLimit​)
​        ​public
​        onlyWallet
​    {
​        dailyLimit ​=​ _dailyLimit;
​        ​DailyLimitChange​(_dailyLimit);
​    }

​    ​/// @dev Allows anyone to execute a confirmed transaction or ether withdraws until daily limit is reached.
​    ​/// @param transactionId Transaction ID.
​    ​function​ executeTransaction​(​uint​ ​transactionId​)
​        ​public
​        ​ownerExists​(​msg​.​sender​)
​        ​confirmed​(transactionId, ​msg​.​sender​)
​        ​notExecuted​(transactionId)
​    {
​        Transaction ​storage​ txn ​=​ transactions[transactionId];
​        ​bool​ _confirmed ​=​ ​isConfirmed​(transactionId);
​        ​if​ (_confirmed ​||​ txn.data.length ​==​ ​0​ ​&&​ ​isUnderLimit​(txn.value)) {
​            txn.executed ​=​ ​true​;
​            ​if​ (​!​_confirmed)
​                spentToday ​+=​ txn.value;
​            ​if​ (​external_call​(txn.destination, txn.value, txn.data.length, txn.data))
​                ​Execution​(transactionId);
​            ​else​ {
​                ​ExecutionFailure​(transactionId);
​                txn.executed ​=​ ​false​;
​                ​if​ (​!​_confirmed)
​                    spentToday ​-=​ txn.value;
​            }
​        }
​    }

​    ​/*
​     * Internal functions
​     */
​    ​/// @dev Returns if amount is within daily limit and resets spentToday after one day.
​    ​/// @param amount Amount to withdraw.
​    ​/// @return Returns if amount is under daily limit.
​    ​function​ isUnderLimit​(​uint​ ​amount​)
​        ​internal
​        ​returns​ (​bool​)
​    {
​        ​if​ (​now​ ​>​ lastDay ​+​ ​24​ ​hours​) {
​            lastDay ​=​ ​now​;
​            spentToday ​=​ ​0​;
​        }
​        ​if​ (spentToday ​+​ amount ​>​ dailyLimit ​||​ spentToday ​+​ amount ​<​ spentToday)
​            ​return​ ​false​;
​        ​return​ ​true​;
​    }

​    ​/*
​     * Web3 call functions
​     */
​    ​/// @dev Returns maximum withdraw amount.
​    ​/// @return Returns amount.
​    ​function​ calcMaxWithdraw​()
​        ​public
​        ​constant
​        ​returns​ (​uint​)
​    {
​        ​if​ (​now​ ​>​ lastDay ​+​ ​24​ ​hours​)
​            ​return​ dailyLimit;
​        ​if​ (dailyLimit ​<​ spentToday)
​            ​return​ ​0​;
​        ​return​ dailyLimit ​-​ spentToday;
​    }
​}

​// File: contracts/MultiSigWalletWithDailyLimitFactory.sol

​pragma solidity​ ​^​0.4.15​;

​/// @title Multisignature wallet factory for daily limit version - Allows creation of multisig wallet.
​/// @author Stefan George - [email protected]
​contract​ ​MultiSigWalletWithDailyLimitFactory​ ​is​ ​Factory​ {

​    ​/*
​     * Public functions
​     */
​    ​/// @dev Allows verified creation of multisignature wallet.
​    ​/// @param _owners List of initial owners.
​    ​/// @param _required Number of required confirmations.
​    ​/// @param _dailyLimit Amount in wei, which can be withdrawn without confirmations on a daily basis.
​    ​/// @return Returns wallet address.
​    ​function​ create​(​address​[] ​_owners​, ​uint​ ​_required​, ​uint​ ​_dailyLimit​)
​        ​public
​        ​returns​ (​address​ ​wallet​)
​    {
​        wallet ​=​ ​new​ ​MultiSigWalletWithDailyLimit​(_owners, _required, _dailyLimit);
​        ​register​(wallet);
​    }
​}