Augustus v5

Allowance should be given to TokenTransferProxy contract and not to AugustusSwapper, FUNDS MAY BE LOST OTHERWISE!

AugustusSwapper

The contract router is responsible for making swaps.

• Mainnet : 0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57

• Arbitrum: 0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57

• Avalanche: 0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57

• Base: 0x59C7C832e96D2568bea6db468C1aAdcbbDa08A52

• BSC: 0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57

• Fantom: 0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57

• Optimism: 0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57

• Polygon: 0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57

• Polygon zkEVM: 0xb83b554730d29ce4cb55bb42206c3e2c03e4a40a

TokenTransferProxy

The Spender contract is responsible for moving ERC20 tokens (and equivalents on side chains). To get the address, you can call getTokenTransferProxy() on Augustus.

• Mainnet: 0x216b4b4ba9f3e719726886d34a177484278bfcae

• Arbitrum: 0x216B4B4Ba9F3e719726886d34a177484278Bfcae

• Avalanche: 0x216b4b4ba9f3e719726886d34a177484278bfcae

• Base: 0x93aAAe79a53759cD164340E4C8766E4Db5331cD7

• BSC: 0x216b4b4ba9f3e719726886d34a177484278bfcae

• Optimism: 0x216B4B4Ba9F3e719726886d34a177484278Bfcae

• Polygon: 0x216b4b4ba9f3e719726886d34a177484278bfcae

• Polygon zkEVM: 0xc8a21fcd5a100c3ecc037c97e2f9c53a8d3a02a1

pragma solidity 0.7.5;


interface ITokenTransferProxy {

    function transferFrom(
        address token,
        address from,
        address to,
        uint256 amount
    )
        external;
}

Augustus Registry

Use AugustusRegistry to verify AugustusSwapper addresses.

• Mainnet: 0xa68bEA62Dc4034A689AA0F58A76681433caCa663

• Arbitrum: 0xdC6E2b14260F972ad4e5a31c68294Fba7E720701

• Avalanche: 0xfD1E5821F07F1aF812bB7F3102Bfd9fFb279513a

• Base: 0x7e31b336f9e8ba52ba3c4ac861b033ba90900bb3

• BSC: 0x05b4486f643914a818ed93afc07457e9074be211

• Fantom: 0x161383b5dAFc1cc05Ec058e5B0b0703BA175bdA6

• Optimism: 0x6e7bE86000dF697facF4396efD2aE2C322165dC3

• Polygon: 0xca35a4866747Ff7A604EF7a2A7F246bb870f3ca1

• Polygon zkEVM: 0x5f34ade3efb2a3f9137ae14568495e8065beea46

interface IAugustusRegistry {

    function isAugustusBanned(address augustus) external view returns (bool);

    function isValidAugustus(address augustus) external view returns (bool);

    function getAugustusCount() external view returns (uint256);

    function getLatestVersion() external view returns (string memory);

    function getLatestAugustus() external view returns (address);

    function getAugustusByVersion(string calldata version) external view returns (address);
}

AugustusSwapper (implements IParaswap through fallback method)

ABI (merged AugustusSwapper and IParaswap ABIs)

34KB

ParaSwap_ABI.json

IAugustusSwapper

interface IAugustusSwapper {
  struct FeeStructure {
    uint256 partnerShare;
    bool noPositiveSlippage;
    bool positiveSlippageToUser;
    uint16 feePercent;
    string partnerId;
    bytes data;
  }

  function DEFAULT_ADMIN_ROLE (  ) external view returns ( bytes32 );
  function ROUTER_ROLE (  ) external view returns ( bytes32 );
  function WHITELISTED_ROLE (  ) external view returns ( bytes32 );
  function getAdapterData ( bytes32 key ) external view returns ( bytes );
  function getFeeWallet (  ) external view returns ( address );
  function getImplementation ( bytes4 selector ) external view returns ( address );
  function getPartnerFeeStructure ( address partner ) external view returns ( FeeStructure memory );
  function getRoleAdmin ( bytes32 role ) external view returns ( bytes32 );
  function getRoleMember ( bytes32 role, uint256 index ) external view returns ( address );
  function getRoleMemberCount ( bytes32 role ) external view returns ( uint256 );
  function getRouterData ( bytes32 key ) external view returns ( bytes );
  function getTokenTransferProxy (  ) external view returns ( address );
  function getVersion (  ) external pure returns ( string );
  function grantRole ( bytes32 role, address account ) external;
  function hasRole ( bytes32 role, address account ) external view returns ( bool );
  function initializeAdapter ( address adapter, bytes data ) external;
  function initializeRouter ( address router, bytes data ) external;
  function isAdapterInitialized ( bytes32 key ) external view returns ( bool );
  function isRouterInitialized ( bytes32 key ) external view returns ( bool );
  function registerPartner ( address partner, uint256 _partnerShare, bool _noPositiveSlippage, bool _positiveSlippageToUser, uint16 _feePercent, string partnerId, bytes _data ) external;
  function renounceRole ( bytes32 role, address account ) external;
  function revokeRole ( bytes32 role, address account ) external;
  function setFeeWallet ( address _feeWallet ) external;
  function setImplementation ( bytes4 selector, address implementation ) external;
  function transferTokens ( address token, address destination, uint256 amount ) external;
}

(Generated from AugustusSwapper ABI using ABI2Solidity tool then edited to add FeeStructure)

IParaswap

pragma solidity 0.7.5;

import "./lib/Utils.sol";

interface IParaswap {
    event Swapped(
        bytes16 uuid,
        address initiator,
        address indexed beneficiary,
        address indexed srcToken,
        address indexed destToken,
        uint256 srcAmount,
        uint256 receivedAmount,
        uint256 expectedAmount
    );

    event Bought(
        bytes16 uuid,
        address initiator,
        address indexed beneficiary,
        address indexed srcToken,
        address indexed destToken,
        uint256 srcAmount,
        uint256 receivedAmount
    );

    event FeeTaken(
        uint256 fee,
        uint256 partnerShare,
        uint256 paraswapShare
    );

    function multiSwap(
        Utils.SellData calldata data
    )
        external
        payable
        returns (uint256);

    function megaSwap(
        Utils.MegaSwapSellData calldata data
    )
        external
        payable
        returns (uint256);

    function protectedMultiSwap(
        Utils.SellData calldata data
    )
        external
        payable
        returns (uint256);

    function protectedMegaSwap(
        Utils.MegaSwapSellData calldata data
    )
        external
        payable
        returns (uint256);

    function protectedSimpleSwap(
        Utils.SimpleData calldata data
    )
        external
        payable
        returns (uint256 receivedAmount);

    function protectedSimpleBuy(
        Utils.SimpleData calldata data
    )
        external
        payable;

    function simpleSwap(
        Utils.SimpleData calldata data
    )
        external
        payable
        returns (uint256 receivedAmount);

    function simpleBuy(
        Utils.SimpleData calldata data
    )
        external
        payable;

    function swapOnUniswap(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path
    )
        external
        payable;

    function swapOnUniswapFork(
        address factory,
        bytes32 initCode,
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path
    )
        external
        payable;

    function buyOnUniswap(
        uint256 amountInMax,
        uint256 amountOut,
        address[] calldata path
    )
        external
        payable;

    function buyOnUniswapFork(
        address factory,
        bytes32 initCode,
        uint256 amountInMax,
        uint256 amountOut,
        address[] calldata path
    )
        external
        payable;

    function swapOnUniswapV2Fork(
        address tokenIn,
        uint256 amountIn,
        uint256 amountOutMin,
        address weth,
        uint256[] calldata pools
    )
        external
        payable;

    function buyOnUniswapV2Fork(
        address tokenIn,
        uint256 amountInMax,
        uint256 amountOut,
        address weth,
        uint256[] calldata pools
    )
        external
        payable;

    function swapOnZeroXv2(
        IERC20 fromToken,
        IERC20 toToken,
        uint256 fromAmount,
        uint256 amountOutMin,
        address exchange,
        bytes calldata payload
    )
    external
    payable;

    function swapOnZeroXv4(
        IERC20 fromToken,
        IERC20 toToken,
        uint256 fromAmount,
        uint256 amountOutMin,
        address exchange,
        bytes calldata payload
    )
    external
    payable;
}

Utils

pragma solidity 0.7.5;

library Utils {
    /**
   * @param fromToken Address of the source token
   * @param fromAmount Amount of source tokens to be swapped
   * @param toAmount Minimum destination token amount expected out of this swap
   * @param expectedAmount Expected amount of destination tokens without slippage
   * @param beneficiary Beneficiary address
   * 0 then 100% will be transferred to beneficiary. Pass 10000 for 100%
   * @param path Route to be taken for this swap to take place

   */
    struct SellData {
        address fromToken;
        uint256 fromAmount;
        uint256 toAmount;
        uint256 expectedAmount;
        address payable beneficiary;
        Utils.Path[] path;
        address payable partner;
        uint256 feePercent;
        bytes permit;
        uint256 deadline;
        bytes16 uuid;
    }

    struct MegaSwapSellData {
        address fromToken;
        uint256 fromAmount;
        uint256 toAmount;
        uint256 expectedAmount;
        address payable beneficiary;
        Utils.MegaSwapPath[] path;
        address payable partner;
        uint256 feePercent;
        bytes permit;
        uint256 deadline;
        bytes16 uuid;
    }

    struct SimpleData {
        address fromToken;
        address toToken;
        uint256 fromAmount;
        uint256 toAmount;
        uint256 expectedAmount;
        address[] callees;
        bytes exchangeData;
        uint256[] startIndexes;
        uint256[] values;
        address payable beneficiary;
        address payable partner;
        uint256 feePercent;
        bytes permit;
        uint256 deadline;
        bytes16 uuid;
    }

    struct Adapter {
        address payable adapter;
        uint256 percent;
        uint256 networkFee;
        Route[] route;
    }

    struct Route {
        uint256 index;//Adapter at which index needs to be used
        address targetExchange;
        uint percent;
        bytes payload;
        uint256 networkFee;//Network fee is associated with 0xv3 trades
    }

    struct MegaSwapPath {
        uint256 fromAmountPercent;
        Path[] path;
    }

    struct Path {
        address to;
        uint256 totalNetworkFee;//Network fee is associated with 0xv3 trades
        Adapter[] adapters;
    }
}

Fee Claimer

• Ethereum: 0xeF13101C5bbD737cFb2bF00Bbd38c626AD6952F7

• Arbitrum: 0xA7465CCD97899edcf11C56D2d26B49125674e45F

• Avalanche: 0xbFcd68FD74B4B458961495F3392Bf96f46A29E67

• Base: 0x9aaB4B24541af30fD72784ED98D8756ac0eFb3C7

• BSC: 0x2DF17455B96Dde3618FD6B1C3a9AA06D6aB89347

• Fantom: 0x4F14fE8c86A00D6DFB9e91239738499Fc0F587De

• Optimism: 0xA7465CCD97899edcf11C56D2d26B49125674e45F

• Polygon: 0x8b5cF413214CA9348F047D1aF402Db1b4E96c06

• Polygon zkEVM: 0x593f39a4ba26a9c8ed2128ac95d109e8e403c485

pragma solidity 0.7.5;

import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

interface IFeeClaimer {
    /**
     * @notice register partner's, affiliate's and PP's fee
     * @dev only callable by AugustusSwapper contract
     * @param _account account address used to withdraw fees
     * @param _token token address
     * @param _fee fee amount in token
     */
    function registerFee(
        address _account,
        IERC20 _token,
        uint256 _fee
    ) external;

    /**
     * @notice claim partner share fee in ERC20 token
     * @dev transfers ERC20 token balance to the caller's account
     *      the call will fail if withdrawer have zero balance in the contract
     * @param _token address of the ERC20 token
     * @param _recipient address
     * @return true if the withdraw was successfull
     */
    function withdrawAllERC20(IERC20 _token, address _recipient) external returns (bool);

    /**
     * @notice batch claim whole balance of fee share amount
     * @dev transfers ERC20 token balance to the caller's account
     *      the call will fail if withdrawer have zero balance in the contract
     * @param _tokens list of addresses of the ERC20 token
     * @param _recipient address of recipient
     * @return true if the withdraw was successfull
     */
    function batchWithdrawAllERC20(IERC20[] calldata _tokens, address _recipient) external returns (bool);

    /**
     * @notice claim some partner share fee in ERC20 token
     * @dev transfers ERC20 token amount to the caller's account
     *      the call will fail if withdrawer have zero balance in the contract
     * @param _token address of the ERC20 token
     * @param _recipient address
     * @return true if the withdraw was successfull
     */
    function withdrawSomeERC20(
        IERC20 _token,
        uint256 _tokenAmount,
        address _recipient
    ) external returns (bool);

    /**
     * @notice batch claim some amount of fee share in ERC20 token
     * @dev transfers ERC20 token balance to the caller's account
     *      the call will fail if withdrawer have zero balance in the contract
     * @param _tokens address of the ERC20 tokens
     * @param _tokenAmounts array of amounts
     * @param _recipient destination account addresses
     * @return true if the withdraw was successfull
     */
    function batchWithdrawSomeERC20(
        IERC20[] calldata _tokens,
        uint256[] calldata _tokenAmounts,
        address _recipient
    ) external returns (bool);

    /**
     * @notice compute unallocated fee in token
     * @param _token address of the ERC20 token
     * @return amount of unallocated token in fees
     */
    function getUnallocatedFees(IERC20 _token) external view returns (uint256);

    /**
     * @notice returns unclaimed fee amount given the token
     * @dev retrieves the balance of ERC20 token fee amount for a partner
     * @param _token address of the ERC20 token
     * @param _partner account address of the partner
     * @return amount of balance
     */
    function getBalance(IERC20 _token, address _partner) external view returns (uint256);

    /**
     * @notice returns unclaimed fee amount given the token in batch
     * @dev retrieves the balance of ERC20 token fee amount for a partner in batch
     * @param _tokens list of ERC20 token addresses
     * @param _partner account address of the partner
     * @return _fees array of the token amount
     */
    function batchGetBalance(IERC20[] calldata _tokens, address _partner)
        external
        view
        returns (uint256[] memory _fees);
}