# Augustus v5 smart contracts

{% hint style="warning" %}
Allowance should be given to **TokenTransferProxy** contract and not to **AugustusSwapper, FUNDS MAY BE LOST OTHERWISE!**
{% endhint %}

## AugustusSwapper

The contract router is responsible for making swaps.

* Mainnet : [<mark style="color:blue;">0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57</mark>](https://etherscan.io/address/0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57#code)
* Arbitrum: [<mark style="color:blue;">0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57</mark>](https://arbiscan.io/address/0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57)
* Avalanche: [<mark style="color:blue;">0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57</mark>](https://cchain.explorer.avax.network/address/0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57/contracts)
* Base: [<mark style="color:blue;">0x59C7C832e96D2568bea6db468C1aAdcbbDa08A52</mark>](https://basescan.org/address/0x59C7C832e96D2568bea6db468C1aAdcbbDa08A52)
* BSC: [<mark style="color:blue;">0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57</mark>](https://bscscan.com/address/0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57#code)
* Optimism: [<mark style="color:blue;">0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57</mark>](https://optimistic.etherscan.io/address/0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57)
* Polygon: [<mark style="color:blue;">0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57</mark>](https://polygonscan.com/address/0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57#code)

![](https://3653627301-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MhY5S0piLthPGntvSF6%2F-Mhm8e5hBU3UTGQeYQAW%2F-Mhm8p5mjBN3H9_VpqC6%2FAugustus.png?alt=media\&token=92d6f5fe-02ba-4c2f-8f52-05506f86ec57)

### 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: [<mark style="color:blue;">0x216b4b4ba9f3e719726886d34a177484278bfcae</mark>](https://etherscan.io/address/0x216b4b4ba9f3e719726886d34a177484278bfcae#code)
* Arbitrum: [<mark style="color:blue;">0x216B4B4Ba9F3e719726886d34a177484278Bfcae</mark>](https://arbiscan.io/address/0x216B4B4Ba9F3e719726886d34a177484278Bfcae)
* Avalanche: [<mark style="color:blue;">0x216b4b4ba9f3e719726886d34a177484278bfcae</mark>](https://cchain.explorer.avax.network/address/0x216B4B4Ba9F3e719726886d34a177484278Bfcae/contracts)
* Base: [<mark style="color:blue;">0x93aAAe79a53759cD164340E4C8766E4Db5331cD7</mark>](https://basescan.org/address/0x93aAAe79a53759cD164340E4C8766E4Db5331cD7)
* BSC: [<mark style="color:blue;">0x216b4b4ba9f3e719726886d34a177484278bfcae</mark>](https://ropsten.etherscan.io/address/0x216b4b4ba9f3e719726886d34a177484278bfcae)
* Optimism: [<mark style="color:blue;">0x216B4B4Ba9F3e719726886d34a177484278Bfcae</mark>](https://optimistic.etherscan.io/address/0x216b4b4ba9f3e719726886d34a177484278bfcae)
* Polygon: [<mark style="color:blue;">0x216b4b4ba9f3e719726886d34a177484278bfcae</mark>](https://polygonscan.com/address/0x216B4B4Ba9F3e719726886d34a177484278Bfcae#code)

```solidity
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: [<mark style="color:blue;">0xa68bEA62Dc4034A689AA0F58A76681433caCa663</mark>](https://etherscan.io/address/0xa68bEA62Dc4034A689AA0F58A76681433caCa663)
* Arbitrum: [<mark style="color:blue;">0xdC6E2b14260F972ad4e5a31c68294Fba7E720701</mark>](https://arbiscan.io/address/0xdC6E2b14260F972ad4e5a31c68294Fba7E720701)
* Avalanche: [<mark style="color:blue;">0xfD1E5821F07F1aF812bB7F3102Bfd9fFb279513a</mark>](https://snowtrace.io/address/0xfD1E5821F07F1aF812bB7F3102Bfd9fFb279513a)
* Base: [<mark style="color:blue;">0x7e31b336f9e8ba52ba3c4ac861b033ba90900bb3</mark>](https://basescan.org/address/0x7e31b336f9e8ba52ba3c4ac861b033ba90900bb3)
* BSC: [<mark style="color:blue;">0x05b4486f643914a818ed93afc07457e9074be211</mark>](https://bscscan.com/address/0x05b4486f643914a818ed93afc07457e9074be211)
* Optimism: [<mark style="color:blue;">0x6e7bE86000dF697facF4396efD2aE2C322165dC3</mark>](https://optimistic.etherscan.io/address/0x6e7bE86000dF697facF4396efD2aE2C322165dC3)
* Polygon: [<mark style="color:blue;">0xca35a4866747Ff7A604EF7a2A7F246bb870f3ca1</mark>](https://polygonscan.com/address/0xca35a4866747Ff7A604EF7a2A7F246bb870f3ca1)

```solidity
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)

{% file src="<https://3653627301-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-MhY5S0piLthPGntvSF6%2F-MjZ7nVxZDaFaYG-PJh_%2F-MjZ8685KZTNGIaoeid5%2FParaSwap_ABI.json?alt=media&token=d3325491-7f79-4f15-8750-aaabb2ab2dc8>" %}

### &#x20;**IAugustusSwapper**

```solidity
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](https://bia.is/tools/abi2solidity/) then edited to add FeeStructure)

### IParaswap

```solidity
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

```solidity
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: [<mark style="color:blue;">0xeF13101C5bbD737cFb2bF00Bbd38c626AD6952F7</mark>](https://etherscan.io/address/0xeF13101C5bbD737cFb2bF00Bbd38c626AD6952F7)
* Arbitrum: [<mark style="color:blue;">0xA7465CCD97899edcf11C56D2d26B49125674e45F</mark>](https://arbiscan.io/address/0xA7465CCD97899edcf11C56D2d26B49125674e45F)
* Avalanche: [<mark style="color:blue;">0xbFcd68FD74B4B458961495F3392Bf96f46A29E67</mark>](https://snowtrace.io/address/0xbFcd68FD74B4B458961495F3392Bf96f46A29E67)
* Base: [<mark style="color:blue;">0x9aaB4B24541af30fD72784ED98D8756ac0eFb3C7</mark>](https://basescan.org/address/0x9aaB4B24541af30fD72784ED98D8756ac0eFb3C7#code)
* BSC: [<mark style="color:blue;">0x2DF17455B96Dde3618FD6B1C3a9AA06D6aB89347</mark>](https://bscscan.com/address/0x2DF17455B96Dde3618FD6B1C3a9AA06D6aB89347)
* Fantom: [<mark style="color:blue;">0x4F14fE8c86A00D6DFB9e91239738499Fc0F587De</mark>](https://ftmscan.com/address/0x4F14fE8c86A00D6DFB9e91239738499Fc0F587De)
* Optimism: [<mark style="color:blue;">0xA7465CCD97899edcf11C56D2d26B49125674e45F</mark>](https://optimistic.etherscan.io/address/0xA7465CCD97899edcf11C56D2d26B49125674e45F)
* Polygon: [<mark style="color:blue;">0x8b5cF413214CA9348F047D1aF402Db1b4E96c06</mark>](https://polygonscan.com/address/0x8b5cF413214CA9348F047D1aF402Db1b4E96c060)

```solidity
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);
}
```