More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 857,789 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Multi Swap | 57192837 | 13 mins ago | IN | 0 AVAX | 0.00069137 | ||||
Simple Swap | 57192716 | 17 mins ago | IN | 10 AVAX | 0.00057967 | ||||
Multi Swap | 57192691 | 18 mins ago | IN | 0 AVAX | 0.00083509 | ||||
Multi Swap | 57192627 | 20 mins ago | IN | 0 AVAX | 0.000577 | ||||
Direct Uni V3Swa... | 57192544 | 22 mins ago | IN | 0 AVAX | 0.00101147 | ||||
Simple Buy | 57192534 | 23 mins ago | IN | 0 AVAX | 0.00035757 | ||||
Mega Swap | 57192148 | 35 mins ago | IN | 0.3 AVAX | 0.00089672 | ||||
Simple Swap | 57191721 | 48 mins ago | IN | 0.5 AVAX | 0.00034317 | ||||
Simple Swap | 57191714 | 48 mins ago | IN | 0.05 AVAX | 0.00038839 | ||||
Simple Swap | 57191052 | 1 hr ago | IN | 0 AVAX | 0.00044685 | ||||
Simple Swap | 57190905 | 1 hr ago | IN | 0.1 AVAX | 0.00038846 | ||||
Simple Swap | 57189476 | 1 hr ago | IN | 0.15 AVAX | 0.00038846 | ||||
Simple Swap | 57187885 | 2 hrs ago | IN | 0.2 AVAX | 0.0003773 | ||||
Simple Swap | 57187707 | 2 hrs ago | IN | 2 AVAX | 0.00040609 | ||||
Multi Swap | 57187417 | 3 hrs ago | IN | 0 AVAX | 0.00058614 | ||||
Simple Swap | 57186752 | 3 hrs ago | IN | 2 AVAX | 0.00037745 | ||||
Simple Swap | 57185698 | 3 hrs ago | IN | 0.04 AVAX | 0.00034683 | ||||
Multi Swap | 57185519 | 3 hrs ago | IN | 0 AVAX | 0.00084408 | ||||
Multi Swap | 57185043 | 4 hrs ago | IN | 0 AVAX | 0.00056465 | ||||
Simple Swap | 57184931 | 4 hrs ago | IN | 0.006 AVAX | 0.0003773 | ||||
Multi Swap | 57184803 | 4 hrs ago | IN | 0 AVAX | 0.00067462 | ||||
Multi Swap | 57183321 | 5 hrs ago | IN | 0 AVAX | 0.00062986 | ||||
Mega Swap | 57182928 | 5 hrs ago | IN | 2 AVAX | 0.00125933 | ||||
Simple Swap | 57182299 | 5 hrs ago | IN | 1.5 AVAX | 0.00035431 | ||||
Simple Swap | 57182073 | 5 hrs ago | IN | 103.6785 AVAX | 0.00064305 |
Latest 25 internal transactions (View All)
Parent Transaction Hash | Block | From | To | |||
---|---|---|---|---|---|---|
57192837 | 13 mins ago | 9.91898321 AVAX | ||||
57192837 | 13 mins ago | 0.41329096 AVAX | ||||
57192837 | 13 mins ago | 10.33227418 AVAX | ||||
57192716 | 17 mins ago | 9 AVAX | ||||
57192716 | 17 mins ago | 1 AVAX | ||||
57192691 | 18 mins ago | 6.18419978 AVAX | ||||
57192691 | 18 mins ago | 6.18419978 AVAX | ||||
57192627 | 20 mins ago | 0.20864295 AVAX | ||||
57192627 | 20 mins ago | 0.20864295 AVAX | ||||
57192534 | 23 mins ago | 2.1 AVAX | ||||
57192534 | 23 mins ago | 2.1 AVAX | ||||
57192148 | 35 mins ago | 0.168 AVAX | ||||
57192148 | 35 mins ago | 0.132 AVAX | ||||
57191721 | 48 mins ago | 0.5 AVAX | ||||
57191714 | 48 mins ago | 0.05 AVAX | ||||
57191052 | 1 hr ago | 34.95405107 AVAX | ||||
57191052 | 1 hr ago | 0.00000271 AVAX | ||||
57191052 | 1 hr ago | 34.95405378 AVAX | ||||
57190905 | 1 hr ago | 0.1 AVAX | ||||
57190421 | 1 hr ago | 1.41207362 AVAX | ||||
57190421 | 1 hr ago | 1.41207362 AVAX | ||||
57190322 | 1 hr ago | 0.49687517 AVAX | ||||
57190322 | 1 hr ago | 0.49687517 AVAX | ||||
57189476 | 1 hr ago | 0.15 AVAX | ||||
57187885 | 2 hrs ago | 0.2 AVAX |
Loading...
Loading
Contract Name:
AugustusSwapper
Compiler Version
v0.7.5+commit.eb77ed08
Contract Source Code (Solidity)
/** *Submitted for verification at snowscan.xyz on 2021-12-29 */ // File: openzeppelin-solidity/contracts/utils/EnumerableSet.sol pragma solidity >=0.6.0 <0.8.0; /** * @dev Library for managing * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive * types. * * Sets have the following properties: * * - Elements are added, removed, and checked for existence in constant time * (O(1)). * - Elements are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableSet for EnumerableSet.AddressSet; * * // Declare a set state variable * EnumerableSet.AddressSet private mySet; * } * ``` * * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`) * and `uint256` (`UintSet`) are supported. */ library EnumerableSet { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Set type with // bytes32 values. // The Set implementation uses private functions, and user-facing // implementations (such as AddressSet) are just wrappers around the // underlying Set. // This means that we can only create new EnumerableSets for types that fit // in bytes32. struct Set { // Storage of set values bytes32[] _values; // Position of the value in the `values` array, plus 1 because index 0 // means a value is not in the set. mapping (bytes32 => uint256) _indexes; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); // The value is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value set._indexes[value] = set._values.length; return true; } else { return false; } } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function _remove(Set storage set, bytes32 value) private returns (bool) { // We read and store the value's index to prevent multiple reads from the same storage slot uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { // Equivalent to contains(set, value) // To delete an element from the _values array in O(1), we swap the element to delete with the last one in // the array, and then remove the last element (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement. bytes32 lastvalue = set._values[lastIndex]; // Move the last value to the index where the value to delete is set._values[toDeleteIndex] = lastvalue; // Update the index for the moved value set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based // Delete the slot where the moved value was stored set._values.pop(); // Delete the index for the deleted slot delete set._indexes[value]; return true; } else { return false; } } /** * @dev Returns true if the value is in the set. O(1). */ function _contains(Set storage set, bytes32 value) private view returns (bool) { return set._indexes[value] != 0; } /** * @dev Returns the number of values on the set. O(1). */ function _length(Set storage set) private view returns (uint256) { return set._values.length; } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Set storage set, uint256 index) private view returns (bytes32) { require(set._values.length > index, "EnumerableSet: index out of bounds"); return set._values[index]; } // Bytes32Set struct Bytes32Set { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _add(set._inner, value); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _remove(set._inner, value); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) { return _contains(set._inner, value); } /** * @dev Returns the number of values in the set. O(1). */ function length(Bytes32Set storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) { return _at(set._inner, index); } // AddressSet struct AddressSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(AddressSet storage set, address value) internal returns (bool) { return _add(set._inner, bytes32(uint256(value))); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(AddressSet storage set, address value) internal returns (bool) { return _remove(set._inner, bytes32(uint256(value))); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(AddressSet storage set, address value) internal view returns (bool) { return _contains(set._inner, bytes32(uint256(value))); } /** * @dev Returns the number of values in the set. O(1). */ function length(AddressSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(AddressSet storage set, uint256 index) internal view returns (address) { return address(uint256(_at(set._inner, index))); } // UintSet struct UintSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(UintSet storage set, uint256 value) internal returns (bool) { return _add(set._inner, bytes32(value)); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(UintSet storage set, uint256 value) internal returns (bool) { return _remove(set._inner, bytes32(value)); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(UintSet storage set, uint256 value) internal view returns (bool) { return _contains(set._inner, bytes32(value)); } /** * @dev Returns the number of values on the set. O(1). */ function length(UintSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(UintSet storage set, uint256 index) internal view returns (uint256) { return uint256(_at(set._inner, index)); } } // File: openzeppelin-solidity/contracts/utils/Address.sol pragma solidity >=0.6.2 <0.8.0; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain`call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } // File: openzeppelin-solidity/contracts/GSN/Context.sol pragma solidity >=0.6.0 <0.8.0; /* * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with GSN meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } } // File: openzeppelin-solidity/contracts/access/AccessControl.sol pragma solidity >=0.6.0 <0.8.0; /** * @dev Contract module that allows children to implement role-based access * control mechanisms. * * Roles are referred to by their `bytes32` identifier. These should be exposed * in the external API and be unique. The best way to achieve this is by * using `public constant` hash digests: * * ``` * bytes32 public constant MY_ROLE = keccak256("MY_ROLE"); * ``` * * Roles can be used to represent a set of permissions. To restrict access to a * function call, use {hasRole}: * * ``` * function foo() public { * require(hasRole(MY_ROLE, msg.sender)); * ... * } * ``` * * Roles can be granted and revoked dynamically via the {grantRole} and * {revokeRole} functions. Each role has an associated admin role, and only * accounts that have a role's admin role can call {grantRole} and {revokeRole}. * * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means * that only accounts with this role will be able to grant or revoke other * roles. More complex role relationships can be created by using * {_setRoleAdmin}. * * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to * grant and revoke this role. Extra precautions should be taken to secure * accounts that have been granted it. */ abstract contract AccessControl is Context { using EnumerableSet for EnumerableSet.AddressSet; using Address for address; struct RoleData { EnumerableSet.AddressSet members; bytes32 adminRole; } mapping (bytes32 => RoleData) private _roles; bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00; /** * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` * * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite * {RoleAdminChanged} not being emitted signaling this. * * _Available since v3.1._ */ event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole); /** * @dev Emitted when `account` is granted `role`. * * `sender` is the account that originated the contract call, an admin role * bearer except when using {_setupRole}. */ event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Emitted when `account` is revoked `role`. * * `sender` is the account that originated the contract call: * - if using `revokeRole`, it is the admin role bearer * - if using `renounceRole`, it is the role bearer (i.e. `account`) */ event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) public view returns (bool) { return _roles[role].members.contains(account); } /** * @dev Returns the number of accounts that have `role`. Can be used * together with {getRoleMember} to enumerate all bearers of a role. */ function getRoleMemberCount(bytes32 role) public view returns (uint256) { return _roles[role].members.length(); } /** * @dev Returns one of the accounts that have `role`. `index` must be a * value between 0 and {getRoleMemberCount}, non-inclusive. * * Role bearers are not sorted in any particular way, and their ordering may * change at any point. * * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure * you perform all queries on the same block. See the following * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post] * for more information. */ function getRoleMember(bytes32 role, uint256 index) public view returns (address) { return _roles[role].members.at(index); } /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) public view returns (bytes32) { return _roles[role].adminRole; } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function grantRole(bytes32 role, address account) public virtual { require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to grant"); _grantRole(role, account); } /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function revokeRole(bytes32 role, address account) public virtual { require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to revoke"); _revokeRole(role, account); } /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been granted `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. */ function renounceRole(bytes32 role, address account) public virtual { require(account == _msgSender(), "AccessControl: can only renounce roles for self"); _revokeRole(role, account); } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. Note that unlike {grantRole}, this function doesn't perform any * checks on the calling account. * * [WARNING] * ==== * This function should only be called from the constructor when setting * up the initial roles for the system. * * Using this function in any other way is effectively circumventing the admin * system imposed by {AccessControl}. * ==== */ function _setupRole(bytes32 role, address account) internal virtual { _grantRole(role, account); } /** * @dev Sets `adminRole` as ``role``'s admin role. * * Emits a {RoleAdminChanged} event. */ function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual { emit RoleAdminChanged(role, _roles[role].adminRole, adminRole); _roles[role].adminRole = adminRole; } function _grantRole(bytes32 role, address account) private { if (_roles[role].members.add(account)) { emit RoleGranted(role, account, _msgSender()); } } function _revokeRole(bytes32 role, address account) private { if (_roles[role].members.remove(account)) { emit RoleRevoked(role, account, _msgSender()); } } } // File: openzeppelin-solidity/contracts/token/ERC20/IERC20.sol pragma solidity >=0.6.0 <0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); } // File: openzeppelin-solidity/contracts/math/SafeMath.sol pragma solidity >=0.6.0 <0.8.0; /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @dev Returns the integer division of two unsigned integers. Reverts on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } /** * @dev Returns the integer division of two unsigned integers. Reverts with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts with custom message when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } // File: openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol pragma solidity >=0.6.0 <0.8.0; /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { using SafeMath for uint256; using Address for address; function safeTransfer(IERC20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove(IERC20 token, address spender, uint256 value) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' // solhint-disable-next-line max-line-length require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).add(value); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } // File: original_contracts/routers/IRouter.sol pragma solidity 0.7.5; interface IRouter { /** * @dev Certain routers/exchanges needs to be initialized. * This method will be called from Augustus */ function initialize(bytes calldata data) external; /** * @dev Returns unique identifier for the router */ function getKey() external pure returns(bytes32); 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 ); } // File: original_contracts/ITokenTransferProxy.sol pragma solidity 0.7.5; interface ITokenTransferProxy { function transferFrom( address token, address from, address to, uint256 amount ) external; } // File: original_contracts/lib/Utils.sol pragma solidity 0.7.5; pragma experimental ABIEncoderV2; interface IERC20Permit { function permit(address owner, address spender, uint256 amount, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external; } library Utils { using SafeMath for uint256; using SafeERC20 for IERC20; address constant ETH_ADDRESS = address( 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE ); uint256 constant MAX_UINT = type(uint256).max; /** * @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; } function ethAddress() internal pure returns (address) {return ETH_ADDRESS;} function maxUint() internal pure returns (uint256) {return MAX_UINT;} function approve( address addressToApprove, address token, uint256 amount ) internal { if (token != ETH_ADDRESS) { IERC20 _token = IERC20(token); uint allowance = _token.allowance(address(this), addressToApprove); if (allowance < amount) { _token.safeApprove(addressToApprove, 0); _token.safeIncreaseAllowance(addressToApprove, MAX_UINT); } } } function transferTokens( address token, address payable destination, uint256 amount ) internal { if (amount > 0) { if (token == ETH_ADDRESS) { (bool result, ) = destination.call{value: amount, gas: 10000}(""); require(result, "Failed to transfer Ether"); } else { IERC20(token).safeTransfer(destination, amount); } } } function tokenBalance( address token, address account ) internal view returns (uint256) { if (token == ETH_ADDRESS) { return account.balance; } else { return IERC20(token).balanceOf(account); } } function permit( address token, bytes memory permit ) internal { if (permit.length == 32 * 7) { (bool success,) = token.call(abi.encodePacked(IERC20Permit.permit.selector, permit)); require(success, "Permit failed"); } } } // File: original_contracts/adapters/IAdapter.sol pragma solidity 0.7.5; interface IAdapter { /** * @dev Certain adapters needs to be initialized. * This method will be called from Augustus */ function initialize(bytes calldata data) external; /** * @dev The function which performs the swap on an exchange. * @param fromToken Address of the source token * @param toToken Address of the destination token * @param fromAmount Amount of source tokens to be swapped * @param networkFee Network fee to be used in this router * @param route Route to be followed */ function swap( IERC20 fromToken, IERC20 toToken, uint256 fromAmount, uint256 networkFee, Utils.Route[] calldata route ) external payable; } // File: openzeppelin-solidity/contracts/access/Ownable.sol pragma solidity >=0.6.0 <0.8.0; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } /** * @dev Returns the address of the current owner. */ function owner() public view returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } // File: original_contracts/TokenTransferProxy.sol pragma solidity 0.7.5; /** * @dev Allows owner of the contract to transfer tokens on behalf of user. * User will need to approve this contract to spend tokens on his/her behalf * on Paraswap platform */ contract TokenTransferProxy is Ownable, ITokenTransferProxy { using SafeERC20 for IERC20; using Address for address; /** * @dev Allows owner of the contract to transfer tokens on user's behalf * @dev Swapper contract will be the owner of this contract * @param token Address of the token * @param from Address from which tokens will be transferred * @param to Receipent address of the tokens * @param amount Amount of tokens to transfer */ function transferFrom( address token, address from, address to, uint256 amount ) external override onlyOwner { require( from == tx.origin || from.isContract(), "Invalid from address" ); IERC20(token).safeTransferFrom(from, to, amount); } } // File: original_contracts/AugustusStorage.sol pragma solidity 0.7.5; contract AugustusStorage { struct FeeStructure { uint256 partnerShare; bool noPositiveSlippage; bool positiveSlippageToUser; uint16 feePercent; string partnerId; bytes data; } ITokenTransferProxy internal tokenTransferProxy; address payable internal feeWallet; mapping(address => FeeStructure) internal registeredPartners; mapping (bytes4 => address) internal selectorVsRouter; mapping (bytes32 => bool) internal adapterInitialized; mapping (bytes32 => bytes) internal adapterVsData; mapping (bytes32 => bytes) internal routerData; mapping (bytes32 => bool) internal routerInitialized; bytes32 public constant WHITELISTED_ROLE = keccak256("WHITELISTED_ROLE"); bytes32 public constant ROUTER_ROLE = keccak256("ROUTER_ROLE"); } // File: original_contracts/AugustusSwapper.sol pragma solidity 0.7.5; contract AugustusSwapper is AugustusStorage, AccessControl { using SafeMath for uint256; using SafeERC20 for IERC20; event AdapterInitialized(address indexed adapter); event RouterInitialized(address indexed router); /** * @dev Throws if called by any account other than the admin. */ modifier onlyAdmin() { require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "caller is not the admin"); _; } constructor(address payable _feeWallet) public { TokenTransferProxy lTokenTransferProxy = new TokenTransferProxy(); tokenTransferProxy = ITokenTransferProxy(lTokenTransferProxy); feeWallet = _feeWallet; _setupRole(DEFAULT_ADMIN_ROLE, msg.sender); } receive () payable external { } fallback() external payable { bytes4 selector = msg.sig; //Figure out the router contract for the given function address implementation = getImplementation(selector); if (implementation == address(0)) { _revertWithData( abi.encodeWithSelector( bytes4(keccak256("NotImplementedError(bytes4)")), selector ) ); } //Delegate call to the router (bool success, bytes memory resultData) = implementation.delegatecall(msg.data); if (!success) { _revertWithData(resultData); } _returnWithData(resultData); } function initializeAdapter(address adapter, bytes calldata data) external onlyAdmin { require( hasRole(WHITELISTED_ROLE, adapter), "Exchange not whitelisted" ); (bool success,) = adapter.delegatecall(abi.encodeWithSelector(IAdapter.initialize.selector, data)); require(success, "Failed to initialize adapter"); emit AdapterInitialized(adapter); } function initializeRouter(address router, bytes calldata data) external onlyAdmin { require( hasRole(ROUTER_ROLE, router), "Router not whitelisted" ); (bool success,) = router.delegatecall(abi.encodeWithSelector(IRouter.initialize.selector, data)); require(success, "Failed to initialize router"); emit RouterInitialized(router); } function getImplementation(bytes4 selector) public view returns(address) { return selectorVsRouter[selector]; } function getVersion() external pure returns(string memory) { return "5.0.0"; } function getPartnerFeeStructure(address partner) public view returns (FeeStructure memory) { return registeredPartners[partner]; } function getFeeWallet() external view returns(address) { return feeWallet; } function setFeeWallet(address payable _feeWallet) external onlyAdmin { require(_feeWallet != address(0), "Invalid address"); feeWallet = _feeWallet; } function registerPartner( address partner, uint256 _partnerShare, bool _noPositiveSlippage, bool _positiveSlippageToUser, uint16 _feePercent, string calldata partnerId, bytes calldata _data ) external onlyAdmin { require(partner != address(0), "Invalid partner"); FeeStructure storage feeStructure = registeredPartners[partner]; require(feeStructure.partnerShare == 0, "Already registered"); require(_partnerShare > 0 && _partnerShare < 10000, "Invalid values"); require(_feePercent <= 10000, "Invalid values"); feeStructure.partnerShare = _partnerShare; feeStructure.noPositiveSlippage = _noPositiveSlippage; feeStructure.positiveSlippageToUser = _positiveSlippageToUser; feeStructure.partnerId = partnerId; feeStructure.feePercent = _feePercent; feeStructure.data = _data; } function setImplementation(bytes4 selector, address implementation) external onlyAdmin { require( hasRole(ROUTER_ROLE, implementation), "Router is not whitelisted" ); selectorVsRouter[selector] = implementation; } /** * @dev Allows admin of the contract to transfer any tokens which are assigned to the contract * This method is for safety if by any chance tokens or ETHs are assigned to the contract by mistake * @dev token Address of the token to be transferred * @dev destination Recepient of the token * @dev amount Amount of tokens to be transferred */ function transferTokens( address token, address payable destination, uint256 amount ) external onlyAdmin { if (amount > 0) { if (token == address(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)) { (bool result, ) = destination.call{value: amount, gas: 10000}(""); require(result, "Failed to transfer Ether"); } else { IERC20(token).safeTransfer(destination, amount); } } } function isAdapterInitialized(bytes32 key) public view returns(bool) { return adapterInitialized[key]; } function getAdapterData(bytes32 key) public view returns(bytes memory) { return adapterVsData[key]; } function isRouterInitialized(bytes32 key) public view returns (bool) { return routerInitialized[key]; } function getRouterData(bytes32 key) public view returns (bytes memory) { return routerData[key]; } function getTokenTransferProxy() public view returns (address) { return address(tokenTransferProxy); } function _revertWithData(bytes memory data) private pure { assembly { revert(add(data, 32), mload(data)) } } function _returnWithData(bytes memory data) private pure { assembly { return(add(data, 32), mload(data)) } } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address payable","name":"_feeWallet","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"adapter","type":"address"}],"name":"AdapterInitialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"router","type":"address"}],"name":"RouterInitialized","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ROUTER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WHITELISTED_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"key","type":"bytes32"}],"name":"getAdapterData","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getFeeWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"selector","type":"bytes4"}],"name":"getImplementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"partner","type":"address"}],"name":"getPartnerFeeStructure","outputs":[{"components":[{"internalType":"uint256","name":"partnerShare","type":"uint256"},{"internalType":"bool","name":"noPositiveSlippage","type":"bool"},{"internalType":"bool","name":"positiveSlippageToUser","type":"bool"},{"internalType":"uint16","name":"feePercent","type":"uint16"},{"internalType":"string","name":"partnerId","type":"string"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct AugustusStorage.FeeStructure","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getRoleMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMemberCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"key","type":"bytes32"}],"name":"getRouterData","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTokenTransferProxy","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getVersion","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"adapter","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"initializeAdapter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"router","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"initializeRouter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"key","type":"bytes32"}],"name":"isAdapterInitialized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"key","type":"bytes32"}],"name":"isRouterInitialized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"partner","type":"address"},{"internalType":"uint256","name":"_partnerShare","type":"uint256"},{"internalType":"bool","name":"_noPositiveSlippage","type":"bool"},{"internalType":"bool","name":"_positiveSlippageToUser","type":"bool"},{"internalType":"uint16","name":"_feePercent","type":"uint16"},{"internalType":"string","name":"partnerId","type":"string"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"registerPartner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"_feeWallet","type":"address"}],"name":"setFeeWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"selector","type":"bytes4"},{"internalType":"address","name":"implementation","type":"address"}],"name":"setImplementation","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address payable","name":"destination","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
0000000000000000000000007f0af2bdfccbfdb0704dcc155f4a9453d2097289
-----Decoded View---------------
Arg [0] : _feeWallet (address): 0x7f0aF2BDfCCBfDB0704DcC155F4a9453D2097289
-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000007f0af2bdfccbfdb0704dcc155f4a9453d2097289
Deployed Bytecode Sourcemap
48568:6131:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49422:15;49440:7;;;;49422:25;;49523:22;49548:27;49566:8;49548:17;:27::i;:::-;49523:52;-1:-1:-1;49590:28:0;;;49586:253;;49635:192;49721:40;49785:8;49669:143;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49635:15;:192::i;:::-;49891:12;49905:23;49932:14;:27;;49960:8;;49932:37;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49890:79;;;;49985:7;49980:68;;50009:27;50025:10;50009:15;:27::i;:::-;50060;50076:10;50060:15;:27::i;:::-;49383:712;;;;48568:6131;52607:271;;;;;;;;;;-1:-1:-1;52607:271:0;;;;;:::i;:::-;;:::i;:::-;;51092:92;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50103:424;;;;;;;;;;-1:-1:-1;50103:424:0;;;;;:::i;:::-;;:::i;22063:114::-;;;;;;;;;;-1:-1:-1;22063:114:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;22439:227::-;;;;;;;;;;-1:-1:-1;22439:227:0;;;;;:::i;:::-;;:::i;48401:62::-;;;;;;;;;;;;;:::i;23648:209::-;;;;;;;;;;-1:-1:-1;23648:209:0;;;;;:::i;:::-;;:::i;53824:118::-;;;;;;;;;;-1:-1:-1;53824:118:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;51344:90::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;50535:409::-;;;;;;;;;;-1:-1:-1;50535:409:0;;;;;:::i;:::-;;:::i;51192:144::-;;;;;;;;;;-1:-1:-1;51192:144:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;48320:72::-;;;;;;;;;;;;;:::i;21736:138::-;;;;;;;;;;-1:-1:-1;21736:138:0;;;;;:::i;:::-;;:::i;51442:173::-;;;;;;;;;;-1:-1:-1;51442:173:0;;;;;:::i;:::-;;:::i;20697:139::-;;;;;;;;;;-1:-1:-1;20697:139:0;;;;;:::i;:::-;;:::i;54073:117::-;;;;;;;;;;-1:-1:-1;54073:117:0;;;;;:::i;:::-;;:::i;53950:115::-;;;;;;;;;;-1:-1:-1;53950:115:0;;;;;:::i;:::-;;:::i;19442:49::-;;;;;;;;;;;;;:::i;53265:549::-;;;;;;;;;;-1:-1:-1;53265:549:0;;;;;:::i;:::-;;:::i;51623:976::-;;;;;;;;;;-1:-1:-1;51623:976:0;;;;;:::i;:::-;;:::i;54198:112::-;;;;;;;;;;-1:-1:-1;54198:112:0;;;;;:::i;:::-;;:::i;21010:127::-;;;;;;;;;;-1:-1:-1;21010:127:0;;;;;:::i;:::-;;:::i;54318:116::-;;;;;;;;;;;;;:::i;22911:230::-;;;;;;;;;;-1:-1:-1;22911:230:0;;;;;:::i;:::-;;:::i;50959:125::-;;;;;;;;;;-1:-1:-1;50959:125:0;;;;;:::i;:::-;51050:26;;;51023:7;51050:26;;;:16;:26;;;;;;;;50959:125;;;;:::o;54442:122::-;54549:4;54543:11;54538:2;54532:4;54528:13;54521:34;54572:122;54679:4;54673:11;54668:2;54662:4;54658:13;54651:34;52607:271;48941:39;19487:4;48969:10;48941:7;:39::i;:::-;48933:75;;;;;;;;;;;;:::i;:::-;;;;;;;;;52727:36:::1;48439:24;52748:14;52727:7;:36::i;:::-;52705:111;;;;;;;;;;;;:::i;:::-;52827:26:::0;;;;::::1;;::::0;;;:16:::1;:26;::::0;;;;:43;;;::::1;;::::0;;::::1;::::0;;;::::1;::::0;;52607:271::o;51092:92::-;51162:14;;;;;;;;;;;;;;;;;51092:92;:::o;50103:424::-;48941:39;19487:4;48969:10;48941:7;:39::i;:::-;48933:75;;;;;;;;;;;;:::i;:::-;50222:34:::1;48363:29;50248:7;50222;:34::i;:::-;50200:108;;;;;;;;;;;;:::i;:::-;50320:12;50337:7;:20;;50381:28;;;50411:4;;50358:58;;;;;;;;;:::i;:::-;;::::0;;;;;::::1;::::0;;;;;;::::1;::::0;::::1;::::0;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;;50337:80;;::::1;::::0;50358:58;50337:80:::1;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50319:98;;;50436:7;50428:48;;;;;;;;;;;;:::i;:::-;50492:27;::::0;::::1;::::0;::::1;::::0;::::1;::::0;;;::::1;49019:1;50103:424:::0;;;:::o;22063:114::-;22120:7;22147:12;;;:6;:12;;;;;:22;;;;22063:114::o;22439:227::-;22531:12;;;;:6;:12;;;;;:22;;;22523:45;;22555:12;:10;:12::i;22523:45::-;22515:105;;;;;;;;;;;;:::i;:::-;22633:25;22644:4;22650:7;22633:10;:25::i;:::-;22439:227;;:::o;48401:62::-;48439:24;48401:62;:::o;23648:209::-;23746:12;:10;:12::i;:::-;23735:23;;:7;:23;;;23727:83;;;;;;;;;;;;:::i;:::-;23823:26;23835:4;23841:7;23823:11;:26::i;53824:118::-;53887:4;53911:23;;;:18;:23;;;;;;;;;53824:118::o;51344:90::-;51417:9;;;;51344:90;:::o;50535:409::-;48941:39;19487:4;48969:10;48941:7;:39::i;:::-;48933:75;;;;;;;;;;;;:::i;:::-;50652:28:::1;48439:24;50673:6;50652:7;:28::i;:::-;50630:100;;;;;;;;;;;;:::i;:::-;50742:12;50759:6;:19;;50802:27;;;50831:4;;50779:57;;;;;;;;;:::i;:::-;;::::0;;;;;::::1;::::0;;;;;;::::1;::::0;::::1;::::0;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;;50759:78;;::::1;::::0;50779:57;50759:78:::1;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50741:96;;;50856:7;50848:47;;;;;;;;;;;;:::i;:::-;50911:25;::::0;::::1;::::0;::::1;::::0;::::1;::::0;;;::::1;49019:1;50535:409:::0;;;:::o;51192:144::-;51262:19;;:::i;:::-;51301:27;;;;;;;:18;:27;;;;;;;;;51294:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51301:27;;51294:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;51294:34:0;;;-1:-1:-1;;51294:34:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51192:144;;;:::o;48320:72::-;48363:29;48320:72;:::o;21736:138::-;21809:7;21836:12;;;:6;:12;;;;;:30;;21860:5;21836:23;:30::i;:::-;21829:37;;21736:138;;;;;:::o;51442:173::-;48941:39;19487:4;48969:10;48941:7;:39::i;:::-;48933:75;;;;;;;;;;;;:::i;:::-;51530:24:::1;::::0;::::1;51522:52;;;;;;;;;;;;:::i;:::-;51585:9;:22:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;51442:173::o;20697:139::-;20766:4;20790:12;;;:6;:12;;;;;:38;;20820:7;20790:29;:38::i;54073:117::-;54136:4;54160:22;;;:17;:22;;;;;;;;;54073:117::o;53950:115::-;54039:18;;;;:13;:18;;;;;;;;;54032:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54007:12;;54032:25;;;54039:18;54032:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53950:115;;;:::o;19442:49::-;19487:4;19442:49;:::o;53265:549::-;48941:39;19487:4;48969:10;48941:7;:39::i;:::-;48933:75;;;;;;;;;;;;:::i;:::-;53440:10;;53436:371:::1;;53471:60;::::0;::::1;53488:42;53471:60;53467:329;;;53553:11;53570;:16;;53594:6;53607:5;53570:47;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53552:65;;;53644:6;53636:43;;;;;;;;;;;;:::i;:::-;53467:329;;;;53733:47;:26;::::0;::::1;53760:11:::0;53773:6;53733:26:::1;:47::i;:::-;53265:549:::0;;;:::o;51623:976::-;48941:39;19487:4;48969:10;48941:7;:39::i;:::-;48933:75;;;;;;;;;;;;:::i;:::-;51947:21:::1;::::0;::::1;51939:49;;;;;;;;;;;;:::i;:::-;52035:27;::::0;::::1;51999:33;52035:27:::0;;;:18:::1;:27;::::0;;;;52081:25;;:30;52073:61:::1;;;;;;;;;;;;:::i;:::-;52169:1;52153:13;:17;:42;;;;;52190:5;52174:13;:21;52153:42;52145:69;;;;;;;;;;;;:::i;:::-;52248:5;52233:11;:20;;;;52225:47;;;;;;;;;;;;:::i;:::-;52285:41:::0;;;52337:31:::1;::::0;::::1;:53:::0;;;::::1;::::0;::::1;;;52401:61:::0;::::1;52337:53;52401:61:::0;::::1;;;;::::0;;52473:34:::1;:22;::::0;::::1;52498:9:::0;;52473:34:::1;:::i;:::-;-1:-1:-1::0;52518:23:0::1;::::0;::::1;:37:::0;;;::::1;::::0;::::1;::::0;::::1;;;::::0;;52566:25:::1;:17;::::0;::::1;52586:5:::0;;52566:25:::1;:::i;:::-;;49019:1;51623:976:::0;;;;;;;;;:::o;54198:112::-;54287:15;;;;:10;:15;;;;;;;;;54280:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54255:12;;54280:22;;;54287:15;54280:22;;;;;;;;;;;;;;;;;;;;;;;;21010:127;21073:7;21100:12;;;:6;:12;;;;;:29;;:27;:29::i;54318:116::-;54372:7;54407:18;;;54318:116;:::o;22911:230::-;23004:12;;;;:6;:12;;;;;:22;;;22996:45;;23028:12;:10;:12::i;22996:45::-;22988:106;;;;;;;;;;;;:::i;6666:143::-;6736:4;6760:41;6765:3;6785:14;;;6760:4;:41::i;17367:106::-;17455:10;17367:106;:::o;24891:188::-;24965:12;;;;:6;:12;;;;;:33;;24990:7;24965:24;:33::i;:::-;24961:111;;;25047:12;:10;:12::i;:::-;25020:40;;25038:7;25020:40;;25032:4;25020:40;;;;;;;;;;24891:188;;:::o;25087:192::-;25162:12;;;;:6;:12;;;;;:36;;25190:7;25162:27;:36::i;:::-;25158:114;;;25247:12;:10;:12::i;:::-;25220:40;;25238:7;25220:40;;25232:4;25220:40;;;;;;;;;;25087:192;;:::o;7925:149::-;7999:7;8042:22;8046:3;8058:5;8042:3;:22::i;7220:158::-;7300:4;7324:46;7334:3;7354:14;;;7324:9;:46::i;34180:177::-;34263:86;34283:5;34313:23;;;34338:2;34342:5;34290:58;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34263:19;:86::i;7464:117::-;7527:7;7554:19;7562:3;7554:7;:19::i;1730:414::-;1793:4;1815:21;1825:3;1830:5;1815:9;:21::i;:::-;1810:327;;-1:-1:-1;1853:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;2036:18;;2014:19;;;:12;;;:19;;;;;;:40;;;;2069:11;;1810:327;-1:-1:-1;2120:5:0;2113:12;;6985:149;7058:4;7082:44;7090:3;7110:14;;;7082:7;:44::i;4618:204::-;4713:18;;4685:7;;4713:26;-1:-1:-1;4705:73:0;;;;;;;;;;;;:::i;:::-;4796:3;:11;;4808:5;4796:18;;;;;;;;;;;;;;;;4789:25;;4618:204;;;;:::o;3950:129::-;4023:4;4047:19;;;:12;;;;;:19;;;;;;:24;;;3950:129::o;36485:761::-;36909:23;36935:69;36963:4;36935:69;;;;;;;;;;;;;;;;;36943:5;36935:27;;;;:69;;;;;:::i;:::-;37019:17;;36909:95;;-1:-1:-1;37019:21:0;37015:224;;37161:10;37150:30;;;;;;;;;;;;:::i;:::-;37142:85;;;;;;;;;;;;:::i;4165:109::-;4248:18;;4165:109::o;2320:1544::-;2386:4;2525:19;;;:12;;;:19;;;;;;2561:15;;2557:1300;;2996:18;;2947:14;;;;;2996:22;;;;2923:21;;2996:3;;:22;;3283;;;;;;;;;;;;;;3263:42;;3429:9;3400:3;:11;;3412:13;3400:26;;;;;;;;;;;;;;;;;;;:38;;;;3506:23;;;3548:1;3506:12;;;:23;;;;;;3532:17;;;3506:43;;3658:17;;3506:3;;3658:17;;;;;;;;;;;;;;;;;;;;;;3753:3;:12;;:19;3766:5;3753:19;;;;;;;;;;;3746:26;;;3796:4;3789:11;;;;;;;;2557:1300;3840:5;3833:12;;;;;13388:195;13491:12;13523:52;13545:6;13553:4;13559:1;13562:12;13523:21;:52::i;:::-;13516:59;;13388:195;;;;;;:::o;14440:530::-;14567:12;14625:5;14600:21;:30;;14592:81;;;;;;;;;;;;:::i;:::-;14692:18;14703:6;14692:10;:18::i;:::-;14684:60;;;;;;;;;;;;:::i;:::-;14818:12;14832:23;14859:6;:11;;14879:5;14887:4;14859:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14817:75;;;;14910:52;14928:7;14937:10;14949:12;14910:17;:52::i;:::-;14903:59;14440:530;-1:-1:-1;;;;;;;14440:530:0:o;10470:422::-;10837:20;10876:8;;;10470:422::o;15976:742::-;16091:12;16120:7;16116:595;;;-1:-1:-1;16151:10:0;16144:17;;16116:595;16265:17;;:21;16261:439;;16528:10;16522:17;16589:15;16576:10;16572:2;16568:19;16561:44;16476:148;16671:12;16664:20;;;;;;;;;;;:::i;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:221:1;83:20;;143:66;132:78;;122:89;;112:2;;225:1;222;215:12;240:377;;;357:3;350:4;342:6;338:17;334:27;324:2;;382:8;372;365:26;324:2;-1:-1:-1;412:20:1;;455:18;444:30;;441:2;;;494:8;484;477:26;441:2;538:4;530:6;526:17;514:29;;590:3;583:4;574:6;566;562:19;558:30;555:39;552:2;;;607:1;604;597:12;552:2;314:303;;;;;:::o;622:259::-;;734:2;722:9;713:7;709:23;705:32;702:2;;;755:6;747;740:22;702:2;799:9;786:23;818:33;845:5;818:33;:::i;1158:478::-;;;;1312:2;1300:9;1291:7;1287:23;1283:32;1280:2;;;1333:6;1325;1318:22;1280:2;1377:9;1364:23;1396:33;1423:5;1396:33;:::i;:::-;1448:5;-1:-1:-1;1505:2:1;1490:18;;1477:32;1518:35;1477:32;1518:35;:::i;:::-;1270:366;;1572:7;;-1:-1:-1;;;1626:2:1;1611:18;;;;1598:32;;1270:366::o;1641:568::-;;;;1789:2;1777:9;1768:7;1764:23;1760:32;1757:2;;;1810:6;1802;1795:22;1757:2;1854:9;1841:23;1873:33;1900:5;1873:33;:::i;:::-;1925:5;-1:-1:-1;1981:2:1;1966:18;;1953:32;2008:18;1997:30;;1994:2;;;2045:6;2037;2030:22;1994:2;2089:60;2141:7;2132:6;2121:9;2117:22;2089:60;:::i;:::-;1747:462;;2168:8;;-1:-1:-1;2063:86:1;;-1:-1:-1;;;;1747:462:1:o;2214:1413::-;;;;;;;;;;2460:3;2448:9;2439:7;2435:23;2431:33;2428:2;;;2482:6;2474;2467:22;2428:2;2526:9;2513:23;2545:33;2572:5;2545:33;:::i;:::-;2597:5;-1:-1:-1;2649:2:1;2634:18;;2621:32;;-1:-1:-1;2705:2:1;2690:18;;2677:32;2718;2677;2718;:::i;:::-;2769:7;-1:-1:-1;2828:2:1;2813:18;;2800:32;2841;2800;2841;:::i;:::-;2892:7;-1:-1:-1;2951:3:1;2936:19;;2923:33;3000:6;2987:20;;2975:33;;2965:2;;3027:6;3019;3012:22;2965:2;3055:7;-1:-1:-1;3113:3:1;3098:19;;3085:33;3137:18;3167:14;;;3164:2;;;3199:6;3191;3184:22;3164:2;3243:60;3295:7;3286:6;3275:9;3271:22;3243:60;:::i;:::-;3322:8;;-1:-1:-1;3217:86:1;-1:-1:-1;3410:3:1;3395:19;;3382:33;;-1:-1:-1;3427:16:1;;;3424:2;;;3461:6;3453;3446:22;3424:2;;3505:62;3559:7;3548:8;3537:9;3533:24;3505:62;:::i;:::-;3479:88;;3586:8;3576:18;;;3613:8;3603:18;;;2418:1209;;;;;;;;;;;:::o;3632:257::-;;3752:2;3740:9;3731:7;3727:23;3723:32;3720:2;;;3773:6;3765;3758:22;3720:2;3810:9;3804:16;3829:30;3853:5;3829:30;:::i;3894:190::-;;4006:2;3994:9;3985:7;3981:23;3977:32;3974:2;;;4027:6;4019;4012:22;3974:2;-1:-1:-1;4055:23:1;;3964:120;-1:-1:-1;3964:120:1:o;4089:327::-;;;4218:2;4206:9;4197:7;4193:23;4189:32;4186:2;;;4239:6;4231;4224:22;4186:2;4280:9;4267:23;4257:33;;4340:2;4329:9;4325:18;4312:32;4353:33;4380:5;4353:33;:::i;:::-;4405:5;4395:15;;;4176:240;;;;;:::o;4421:258::-;;;4550:2;4538:9;4529:7;4525:23;4521:32;4518:2;;;4571:6;4563;4556:22;4518:2;-1:-1:-1;;4599:23:1;;;4669:2;4654:18;;;4641:32;;-1:-1:-1;4508:171:1:o;4684:196::-;;4795:2;4783:9;4774:7;4770:23;4766:32;4763:2;;;4816:6;4808;4801:22;4763:2;4844:30;4864:9;4844:30;:::i;4885:333::-;;;5013:2;5001:9;4992:7;4988:23;4984:32;4981:2;;;5034:6;5026;5019:22;4981:2;5062:30;5082:9;5062:30;:::i;:::-;5052:40;;5142:2;5131:9;5127:18;5114:32;5155:33;5182:5;5155:33;:::i;5223:318::-;;5304:5;5298:12;5331:6;5326:3;5319:19;5347:63;5403:6;5396:4;5391:3;5387:14;5380:4;5373:5;5369:16;5347:63;:::i;:::-;5455:2;5443:15;5460:66;5439:88;5430:98;;;;5530:4;5426:109;;5274:267;-1:-1:-1;;5274:267:1:o;5546:273::-;;5729:6;5721;5716:3;5703:33;5755:16;;5780:15;;;5755:16;5693:126;-1:-1:-1;5693:126:1:o;5824:274::-;;5991:6;5985:13;6007:53;6053:6;6048:3;6041:4;6033:6;6029:17;6007:53;:::i;:::-;6076:16;;;;;5961:137;-1:-1:-1;;5961:137:1:o;6103:205::-;6303:3;6294:14::o;6313:226::-;6489:42;6477:55;;;;6459:74;;6447:2;6432:18;;6414:125::o;6544:297::-;6748:42;6736:55;;;;6718:74;;6823:2;6808:18;;6801:34;6706:2;6691:18;;6673:168::o;6846:187::-;7011:14;;7004:22;6986:41;;6974:2;6959:18;;6941:92::o;7038:177::-;7184:25;;;7172:2;7157:18;;7139:76::o;7220:248::-;7394:66;7382:79;;;;7364:98;;7352:2;7337:18;;7319:149::o;7473:450::-;;7630:2;7619:9;7612:21;7669:6;7664:2;7653:9;7649:18;7642:34;7726:6;7718;7713:2;7702:9;7698:18;7685:48;7753:22;;;7777:2;7749:31;;;7742:45;;;;7839:2;7827:15;;;7844:66;7823:88;7808:104;7804:113;;7602:321;-1:-1:-1;7602:321:1:o;7928:219::-;;8075:2;8064:9;8057:21;8095:46;8137:2;8126:9;8122:18;8114:6;8095:46;:::i;8378:348::-;8580:2;8562:21;;;8619:2;8599:18;;;8592:30;8658:26;8653:2;8638:18;;8631:54;8717:2;8702:18;;8552:174::o;8731:398::-;8933:2;8915:21;;;8972:2;8952:18;;;8945:30;9011:34;9006:2;8991:18;;8984:62;9082:4;9077:2;9062:18;;9055:32;9119:3;9104:19;;8905:224::o;9134:411::-;9336:2;9318:21;;;9375:2;9355:18;;;9348:30;9414:34;9409:2;9394:18;;9387:62;9485:17;9480:2;9465:18;;9458:45;9535:3;9520:19;;9308:237::o;9550:339::-;9752:2;9734:21;;;9791:2;9771:18;;;9764:30;9830:17;9825:2;9810:18;;9803:45;9880:2;9865:18;;9724:165::o;9894:338::-;10096:2;10078:21;;;10135:2;10115:18;;;10108:30;10174:16;10169:2;10154:18;;10147:44;10223:2;10208:18;;10068:164::o;10237:351::-;10439:2;10421:21;;;10478:2;10458:18;;;10451:30;10517:29;10512:2;10497:18;;10490:57;10579:2;10564:18;;10411:177::o;10593:342::-;10795:2;10777:21;;;10834:2;10814:18;;;10807:30;10873:20;10868:2;10853:18;;10846:48;10926:2;10911:18;;10767:168::o;10940:352::-;11142:2;11124:21;;;11181:2;11161:18;;;11154:30;11220;11215:2;11200:18;;11193:58;11283:2;11268:18;;11114:178::o;11297:346::-;11499:2;11481:21;;;11538:2;11518:18;;;11511:30;11577:24;11572:2;11557:18;;11550:52;11634:2;11619:18;;11471:172::o;11648:402::-;11850:2;11832:21;;;11889:2;11869:18;;;11862:30;11928:34;11923:2;11908:18;;11901:62;11999:8;11994:2;11979:18;;11972:36;12040:3;12025:19;;11822:228::o;12055:349::-;12257:2;12239:21;;;12296:2;12276:18;;;12269:30;12335:27;12330:2;12315:18;;12308:55;12395:2;12380:18;;12229:175::o;12409:412::-;12611:2;12593:21;;;12650:2;12630:18;;;12623:30;12689:34;12684:2;12669:18;;12662:62;12760:18;12755:2;12740:18;;12733:46;12811:3;12796:19;;12583:238::o;12826:339::-;13028:2;13010:21;;;13067:2;13047:18;;;13040:30;13106:17;13101:2;13086:18;;13079:45;13156:2;13141:18;;13000:165::o;13170:348::-;13372:2;13354:21;;;13411:2;13391:18;;;13384:30;13450:26;13445:2;13430:18;;13423:54;13509:2;13494:18;;13344:174::o;13523:353::-;13725:2;13707:21;;;13764:2;13744:18;;;13737:30;13803:31;13798:2;13783:18;;13776:59;13867:2;13852:18;;13697:179::o;13881:406::-;14083:2;14065:21;;;14122:2;14102:18;;;14095:30;14161:34;14156:2;14141:18;;14134:62;14232:12;14227:2;14212:18;;14205:40;14277:3;14262:19;;14055:232::o;14292:347::-;14494:2;14476:21;;;14533:2;14513:18;;;14506:30;14572:25;14567:2;14552:18;;14545:53;14630:2;14615:18;;14466:173::o;14644:411::-;14846:2;14828:21;;;14885:2;14865:18;;;14858:30;14924:34;14919:2;14904:18;;14897:62;14995:17;14990:2;14975:18;;14968:45;15045:3;15030:19;;14818:237::o;15060:888::-;;15249:2;15238:9;15231:21;15294:6;15288:13;15283:2;15272:9;15268:18;15261:41;15370:2;15362:6;15358:15;15352:22;15345:30;15338:38;15333:2;15322:9;15318:18;15311:66;15445:2;15437:6;15433:15;15427:22;15420:30;15413:38;15408:2;15397:9;15393:18;15386:66;15517:6;15511:2;15503:6;15499:15;15493:22;15489:35;15483:3;15472:9;15468:19;15461:64;15572:3;15564:6;15560:16;15554:23;15614:4;15608:3;15597:9;15593:19;15586:33;15642:53;15690:3;15679:9;15675:19;15661:12;15642:53;:::i;:::-;15628:67;;15744:3;15736:6;15732:16;15726:23;15815:66;15803:9;15795:6;15791:22;15787:95;15780:4;15769:9;15765:20;15758:125;15900:42;15935:6;15919:14;15900:42;:::i;:::-;15892:50;15221:727;-1:-1:-1;;;;;15221:727:1:o;16135:258::-;16207:1;16217:113;16231:6;16228:1;16225:13;16217:113;;;16307:11;;;16301:18;16288:11;;;16281:39;16253:2;16246:10;16217:113;;;16348:6;16345:1;16342:13;16339:2;;;16383:1;16374:6;16369:3;16365:16;16358:27;16339:2;;16188:205;;;:::o;16398:156::-;16486:42;16479:5;16475:54;16468:5;16465:65;16455:2;;16544:1;16541;16534:12;16455:2;16445:109;:::o;16559:120::-;16647:5;16640:13;16633:21;16626:5;16623:32;16613:2;;16669:1;16666;16659:12
Swarm Source
ipfs://a043bdd05a1c168f623a894430cb3a50964c5c00c776399fa2c32e4b6de6029a
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|---|---|---|---|---|
BSC | 88.37% | $0.046323 | 50,000 | $2,316.16 | |
BSC | 0.03% | $1.38 | 0.55 | $0.7599 | |
ZKSYNC | 9.15% | $2,587.31 | 0.0927 | $239.91 | |
FTM | 2.28% | $0.002092 | 28,625.4874 | $59.87 | |
OPBNB | 0.12% | $628.46 | 0.00516 | $3.24 | |
ETH | 0.02% | $0.000145 | 3,426.97 | $0.4959 | |
SCROLL | 0.01% | $2,584.95 | 0.00012256 | $0.316812 | |
CELO | <0.01% | $0.433567 | 0.128 | $0.055489 | |
BLAST | <0.01% | $2,586.99 | 0.0000092 | $0.023799 | |
MOVR | <0.01% | $7.52 | 0.001 | $0.007522 | |
AVAX | <0.01% | $25.05 | 0.000000000000000001 | <$0.000001 |
[ Download: CSV Export ]
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.