Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
TokenTracker
Latest 25 from a total of 25 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Approve | 18072752 | 366 days ago | IN | 0 ETH | 0.00205159 | ||||
Approve | 14989488 | 810 days ago | IN | 0 ETH | 0.00067769 | ||||
Approve | 14497163 | 889 days ago | IN | 0 ETH | 0.00193123 | ||||
Approve | 13847759 | 990 days ago | IN | 0 ETH | 0.00149939 | ||||
Approve | 13748117 | 1005 days ago | IN | 0 ETH | 0.00369937 | ||||
Approve | 13625058 | 1025 days ago | IN | 0 ETH | 0.00560617 | ||||
Approve | 13624263 | 1025 days ago | IN | 0 ETH | 0.00668192 | ||||
Approve | 13620072 | 1025 days ago | IN | 0 ETH | 0.00524488 | ||||
Approve | 13616843 | 1026 days ago | IN | 0 ETH | 0.00664937 | ||||
Approve | 13614309 | 1026 days ago | IN | 0 ETH | 0.00453303 | ||||
Approve | 13614284 | 1026 days ago | IN | 0 ETH | 0.00466144 | ||||
Transfer | 13614268 | 1026 days ago | IN | 0 ETH | 0.00503091 | ||||
Approve | 13614261 | 1026 days ago | IN | 0 ETH | 0.00421304 | ||||
Transfer | 13614247 | 1026 days ago | IN | 0 ETH | 0.00457615 | ||||
Approve | 13614202 | 1026 days ago | IN | 0 ETH | 0.00496648 | ||||
Approve | 13614145 | 1026 days ago | IN | 0 ETH | 0.00446465 | ||||
Approve | 13605619 | 1028 days ago | IN | 0 ETH | 0.00429003 | ||||
Approve | 13604483 | 1028 days ago | IN | 0 ETH | 0.00513187 | ||||
Approve | 13600045 | 1029 days ago | IN | 0 ETH | 0.00301918 | ||||
Approve | 13600037 | 1029 days ago | IN | 0 ETH | 0.00610852 | ||||
Approve | 13599105 | 1029 days ago | IN | 0 ETH | 0.00774982 | ||||
Approve | 13596149 | 1029 days ago | IN | 0 ETH | 0.0082171 | ||||
Approve | 13577110 | 1032 days ago | IN | 0 ETH | 0.00676115 | ||||
Set Two Way | 13178369 | 1094 days ago | IN | 0 ETH | 0.00369072 | ||||
0x60806040 | 13178366 | 1094 days ago | IN | 0 ETH | 0.18553344 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
SwapPair
Compiler Version
v0.8.6+commit.11564f7e
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2021-11-14 */ // Sources flattened with hardhat v2.6.7 https://hardhat.org // File @openzeppelin/contracts/utils/math/[email protected] // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; // CAUTION // This version of SafeMath should only be used with Solidity 0.8 or later, // because it relies on the compiler's built in overflow checks. /** * @dev Wrappers over Solidity's arithmetic operations. * * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler * now has built in overflow checking. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } } /** * @dev Returns the substraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b > a) return (false, 0); return (true, a - b); } } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { // 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 (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a / b); } } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a % b); } } /** * @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) { return a + b; } /** * @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 a - b; } /** * @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) { return a * b; } /** * @dev Returns the integer division of two unsigned integers, reverting on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting 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 a % b; } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {trySub}. * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b <= a, errorMessage); return a - b; } } /** * @dev Returns the integer division of two unsigned integers, reverting 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) { unchecked { require(b > 0, errorMessage); return a / b; } } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting with custom message when dividing by zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryMod}. * * 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) { unchecked { require(b > 0, errorMessage); return a % b; } } } // File @openzeppelin/contracts/token/ERC20/[email protected] // sp-License-Identifier: MIT pragma solidity ^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/contracts/token/ERC20/extensions/[email protected] // sp-License-Identifier: MIT pragma solidity ^0.8.0; /** * @dev Interface for the optional metadata functions from the ERC20 standard. * * _Available since v4.1._ */ interface IERC20Metadata is IERC20 { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token. */ function symbol() external view returns (string memory); /** * @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); } // File @openzeppelin/contracts/utils/[email protected] // sp-License-Identifier: MIT pragma solidity ^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 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) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } // File @openzeppelin/contracts/token/ERC20/[email protected] // sp-License-Identifier: MIT pragma solidity ^0.8.0; /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin Contracts guidelines: functions revert * instead returning `false` on failure. This behavior is nonetheless * conventional and does not conflict with the expectations of ERC20 * applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20 is Context, IERC20, IERC20Metadata { mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; /** * @dev Sets the values for {name} and {symbol}. * * The default value of {decimals} is 18. To select a different value for * {decimals} you should overload it. * * All two of these values are immutable: they can only be set once during * construction. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev Returns the name of the token. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5.05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the value {ERC20} uses, unless this function is * overridden; * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view virtual override returns (uint8) { return 18; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `recipient` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}. * * Requirements: * * - `sender` and `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. * - the caller must have allowance for ``sender``'s tokens of at least * `amount`. */ function transferFrom( address sender, address recipient, uint256 amount ) public virtual override returns (bool) { _transfer(sender, recipient, amount); uint256 currentAllowance = _allowances[sender][_msgSender()]; require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance"); unchecked { _approve(sender, _msgSender(), currentAllowance - amount); } return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { uint256 currentAllowance = _allowances[_msgSender()][spender]; require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); unchecked { _approve(_msgSender(), spender, currentAllowance - subtractedValue); } return true; } /** * @dev Moves `amount` of tokens from `sender` to `recipient`. * * This internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `sender` cannot be the zero address. * - `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. */ function _transfer( address sender, address recipient, uint256 amount ) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(sender, recipient, amount); uint256 senderBalance = _balances[sender]; require(senderBalance >= amount, "ERC20: transfer amount exceeds balance"); unchecked { _balances[sender] = senderBalance - amount; } _balances[recipient] += amount; emit Transfer(sender, recipient, amount); _afterTokenTransfer(sender, recipient, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply += amount; _balances[account] += amount; emit Transfer(address(0), account, amount); _afterTokenTransfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); uint256 accountBalance = _balances[account]; require(accountBalance >= amount, "ERC20: burn amount exceeds balance"); unchecked { _balances[account] = accountBalance - amount; } _totalSupply -= amount; emit Transfer(account, address(0), amount); _afterTokenTransfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens. * * This internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. */ function _approve( address owner, address spender, uint256 amount ) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * will be transferred to `to`. * - when `from` is zero, `amount` tokens will be minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256 amount ) internal virtual {} /** * @dev Hook that is called after any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * has been transferred to `to`. * - when `from` is zero, `amount` tokens have been minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens have been burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer( address from, address to, uint256 amount ) internal virtual {} } // File @openzeppelin/contracts/utils/[email protected] // sp-License-Identifier: MIT pragma solidity ^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; 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"); (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"); (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"); (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal 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 assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } // File @openzeppelin/contracts/token/ERC20/utils/[email protected] // sp-License-Identifier: MIT pragma solidity ^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 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' 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) + value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance( IERC20 token, address spender, uint256 value ) internal { unchecked { uint256 oldAllowance = token.allowance(address(this), spender); require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); uint256 newAllowance = oldAllowance - value; _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 require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } // File @openzeppelin/contracts/utils/structs/[email protected] // sp-License-Identifier: MIT pragma solidity ^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; if (lastIndex != toDeleteIndex) { 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] = valueIndex; // Replace lastvalue's index to valueIndex } // 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) { return set._values[index]; } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function _values(Set storage set) private view returns (bytes32[] memory) { return set._values; } // 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); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(Bytes32Set storage set) internal view returns (bytes32[] memory) { return _values(set._inner); } // 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(uint160(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(uint160(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(uint160(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(uint160(uint256(_at(set._inner, index)))); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(AddressSet storage set) internal view returns (address[] memory) { bytes32[] memory store = _values(set._inner); address[] memory result; assembly { result := store } return result; } // 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)); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(UintSet storage set) internal view returns (uint256[] memory) { bytes32[] memory store = _values(set._inner); uint256[] memory result; assembly { result := store } return result; } } // File @openzeppelin/contracts/access/[email protected] // sp-License-Identifier: MIT pragma solidity ^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() { _setOwner(_msgSender()); } /** * @dev Returns the address of the current owner. */ function owner() public view virtual 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 { _setOwner(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"); _setOwner(newOwner); } function _setOwner(address newOwner) private { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } // File contracts/interface/IBoringToken.sol // sp-License-Identifier: MIT pragma solidity ^0.8.0; interface IBoringToken is IERC20 { function mint(address to, uint256 amount) external; function burn(address from, uint256 amount) external; } // File contracts/twoway/struct.sol // sp-License-Identifier: MIT pragma solidity ^0.8.0; struct SwapInParams { address to; uint amount1; uint feeAmountFix; uint remainAmount; address feeToDev; uint chainID; } // File contracts/interface/ISwapPair.sol // sp-License-Identifier: MIT pragma solidity ^0.8.0; interface ISwapPair { function mint(address to) external returns (uint256 liquidity); function burn( address from, address to, uint256 amount, address feeTo, uint256 feeAmount ) external returns ( uint256, uint256[] memory, uint256[] memory ); function token0() external returns (address); function swapOut( address to, uint256 amount, uint256 chainid ) external; // direction: token0 -> token1 or token1 -> token0 // function swapIn( // address to, // uint256 amount, // uint256 feeAmountFix, // uint256 remainAmount, // address feeToDev, // uint256 chainid // ) external; function swapIn( SwapInParams memory params ) external; function getReserves(uint256 chainid) external view returns (uint256, uint256); function update() external; function diff0() external returns (uint256); function addChainIDs(uint256[] memory chainids) external; function removeChainIDs(uint256[] memory chainids) external; } // File contracts/lib/SafeDecimalMath.sol // sp-License-Identifier: MIT pragma solidity ^0.8.0; // Libraries // https://docs.synthetix.io/contracts/SafeDecimalMath library SafeDecimalMath { using SafeMath for uint; /* Number of decimal places in the representations. */ uint8 public constant decimals = 18; uint8 public constant highPrecisionDecimals = 27; /* The number representing 1.0. */ uint public constant UNIT = 10**uint(decimals); /* The number representing 1.0 for higher fidelity numbers. */ uint public constant PRECISE_UNIT = 10**uint(highPrecisionDecimals); uint private constant UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR = 10**uint(highPrecisionDecimals - decimals); /** * @return Provides an interface to UNIT. */ function unit() external pure returns (uint) { return UNIT; } /** * @return Provides an interface to PRECISE_UNIT. */ function preciseUnit() external pure returns (uint) { return PRECISE_UNIT; } /** * @return The result of multiplying x and y, interpreting the operands as fixed-point * decimals. * * @dev A unit factor is divided out after the product of x and y is evaluated, * so that product must be less than 2**256. As this is an integer division, * the internal division always rounds down. This helps save on gas. Rounding * is more expensive on gas. */ function multiplyDecimal(uint x, uint y) internal pure returns (uint) { /* Divide by UNIT to remove the extra factor introduced by the product. */ return x.mul(y) / UNIT; } /** * @return The result of safely multiplying x and y, interpreting the operands * as fixed-point decimals of the specified precision unit. * * @dev The operands should be in the form of a the specified unit factor which will be * divided out after the product of x and y is evaluated, so that product must be * less than 2**256. * * Unlike multiplyDecimal, this function rounds the result to the nearest increment. * Rounding is useful when you need to retain fidelity for small decimal numbers * (eg. small fractions or percentages). */ function _multiplyDecimalRound( uint x, uint y, uint precisionUnit ) private pure returns (uint) { /* Divide by UNIT to remove the extra factor introduced by the product. */ uint quotientTimesTen = x.mul(y) / (precisionUnit / 10); if (quotientTimesTen % 10 >= 5) { quotientTimesTen += 10; } return quotientTimesTen / 10; } /** * @return The result of safely multiplying x and y, interpreting the operands * as fixed-point decimals of a precise unit. * * @dev The operands should be in the precise unit factor which will be * divided out after the product of x and y is evaluated, so that product must be * less than 2**256. * * Unlike multiplyDecimal, this function rounds the result to the nearest increment. * Rounding is useful when you need to retain fidelity for small decimal numbers * (eg. small fractions or percentages). */ function multiplyDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) { return _multiplyDecimalRound(x, y, PRECISE_UNIT); } /** * @return The result of safely multiplying x and y, interpreting the operands * as fixed-point decimals of a standard unit. * * @dev The operands should be in the standard unit factor which will be * divided out after the product of x and y is evaluated, so that product must be * less than 2**256. * * Unlike multiplyDecimal, this function rounds the result to the nearest increment. * Rounding is useful when you need to retain fidelity for small decimal numbers * (eg. small fractions or percentages). */ function multiplyDecimalRound(uint x, uint y) internal pure returns (uint) { return _multiplyDecimalRound(x, y, UNIT); } /** * @return The result of safely dividing x and y. The return value is a high * precision decimal. * * @dev y is divided after the product of x and the standard precision unit * is evaluated, so the product of x and UNIT must be less than 2**256. As * this is an integer division, the result is always rounded down. * This helps save on gas. Rounding is more expensive on gas. */ function divideDecimal(uint x, uint y) internal pure returns (uint) { /* Reintroduce the UNIT factor that will be divided out by y. */ return x.mul(UNIT).div(y); } /** * @return The result of safely dividing x and y. The return value is as a rounded * decimal in the precision unit specified in the parameter. * * @dev y is divided after the product of x and the specified precision unit * is evaluated, so the product of x and the specified precision unit must * be less than 2**256. The result is rounded to the nearest increment. */ function _divideDecimalRound( uint x, uint y, uint precisionUnit ) private pure returns (uint) { uint resultTimesTen = x.mul(precisionUnit * 10).div(y); if (resultTimesTen % 10 >= 5) { resultTimesTen += 10; } return resultTimesTen / 10; } /** * @return The result of safely dividing x and y. The return value is as a rounded * standard precision decimal. * * @dev y is divided after the product of x and the standard precision unit * is evaluated, so the product of x and the standard precision unit must * be less than 2**256. The result is rounded to the nearest increment. */ function divideDecimalRound(uint x, uint y) internal pure returns (uint) { return _divideDecimalRound(x, y, UNIT); } /** * @return The result of safely dividing x and y. The return value is as a rounded * high precision decimal. * * @dev y is divided after the product of x and the high precision unit * is evaluated, so the product of x and the high precision unit must * be less than 2**256. The result is rounded to the nearest increment. */ function divideDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) { return _divideDecimalRound(x, y, PRECISE_UNIT); } /** * @dev Convert a standard decimal representation to a high precision one. */ function decimalToPreciseDecimal(uint i) internal pure returns (uint) { return i.mul(UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR); } /** * @dev Convert a high precision decimal to a standard decimal representation. */ function preciseDecimalToDecimal(uint i) internal pure returns (uint) { uint quotientTimesTen = i / (UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR / 10); if (quotientTimesTen % 10 >= 5) { quotientTimesTen += 10; } return quotientTimesTen / 10; } } // File contracts/twoway/SwapPair.sol // sp-License-Identifier: MIT pragma solidity ^0.8.0; contract SwapPair is ERC20, Ownable, ISwapPair { using SafeMath for uint256; using SafeERC20 for IERC20; using SafeDecimalMath for uint256; using EnumerableSet for EnumerableSet.UintSet; address public override token0; // origin erc20 token uint256 public reserve0; EnumerableSet.UintSet private supportChainids; mapping(uint256 => uint256) public reserve1s; uint256 public totalReserve1s; address public twoWay; uint256 public override diff0; event Mint(address indexed sender, uint256 amount); event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to); event Swap(address indexed sender, uint256 amountIn, uint256 amountOut, address indexed to); constructor( string memory _name, string memory _symbol, address _token0 ) ERC20(_name, _symbol) { uint256 token0Decimals = IERC20Metadata(_token0).decimals(); require(token0Decimals < 19, "token0 decimals too big"); token0 = _token0; diff0 = 10**(18 - token0Decimals); } // ======view===== function getReserves(uint256 chainId) public view override returns (uint256, uint256) { return (reserve0, reserve1s[chainId]); } function getSupportChainIDs() external view returns(uint256[] memory) { uint[] memory chainids = new uint256[](supportChainids.length()); for (uint i; i < supportChainids.length(); i++) { chainids[i] = supportChainids.at(i); } return chainids; } function setTwoWay(address _twoWay) external onlyOwner { twoWay = _twoWay; } function addChainIDs(uint256[] memory chainids) external override onlyTwoWay { for (uint256 i; i < chainids.length; i++) { supportChainids.add(chainids[i]); } } function removeChainIDs(uint256[] memory chainids) external override onlyTwoWay { for (uint256 i; i < chainids.length; i++) { supportChainids.remove(chainids[i]); } } function mint(address to) external override onlyTwoWay returns (uint256 lpAmount) { uint256 balance0 = IERC20(token0).balanceOf(address(this)); uint256 amount0 = balance0.sub(reserve0); lpAmount = getLPAmount(amount0); require(lpAmount > 0, "SwapPair: insufficient liquidity minted"); _mint(to, lpAmount); // update reserves reserve0 = balance0; emit Mint(msg.sender, lpAmount); } function getLPAmount(uint256 amount) public view returns (uint256 lpAmount) { uint256 amountAdjust = amount * diff0; uint256 _reserve0 = reserve0 * diff0; uint256 total = totalSupply(); if (total == 0) { lpAmount = amountAdjust; } else { lpAmount = (amountAdjust * total) / (totalReserve1s + _reserve0); } } function burn( address from, address to, uint256 lpAmount, address feeTo, uint256 feeAmount ) external override onlyTwoWay returns ( uint256, uint256[] memory, uint256[] memory ) { (uint256 amount0, uint256[] memory chainids, uint256[] memory amount1s) = calculateBurn(lpAmount); IERC20(token0).transfer(from, amount0 - feeAmount); if (feeAmount > 0) { IERC20(token0).transfer(feeTo, feeAmount); } uint256 totalRemove; for (uint256 i; i < chainids.length; i++) { if (amount1s[i] > 0) { reserve1s[chainids[i]] -= amount1s[i]; totalRemove += amount1s[i]; } } _burn(from, lpAmount); // current balance uint256 balance0 = IERC20(token0).balanceOf(address(this)); // update reserves reserve0 = balance0; totalReserve1s -= totalRemove; emit Burn(msg.sender, amount0, totalRemove, to); return (amount0, chainids, amount1s); } function calculateBurn(uint256 lpAmount) public view returns ( uint256, uint256[] memory, uint256[] memory ) { uint256 _reserve0 = reserve0 * diff0; uint256 _totalSupply = totalSupply(); uint256 value = (lpAmount * (_reserve0 + totalReserve1s)) / _totalSupply; if (value <= _reserve0) { uint256 amount0 = value / diff0; uint256[] memory chainids = new uint256[](0); uint256[] memory amounts = new uint256[](0); return (amount0, chainids, amounts); } else { uint256 amount = value - _reserve0; uint256 chainidLength = supportChainids.length(); uint256[] memory chainids = new uint256[](chainidLength); uint256[] memory amounts = new uint256[](chainidLength); for (uint256 i; i < chainidLength; i++) { uint256 chainid = supportChainids.at(i); if (reserve1s[chainid] >= amount) { chainids[i] = chainid; amounts[i] = amount; break; } else { chainids[i] = chainid; amounts[i] = reserve1s[chainid]; amount = amount - reserve1s[chainid]; } } return (reserve0, chainids, amounts); } } function update() external override onlyTwoWay { uint256 balance0 = IERC20(token0).balanceOf(address(this)); reserve0 = balance0; } function swapOut( address to, uint256 amount0, uint256 chainID ) external override onlyTwoWay onlySupportChainID(chainID) { (, uint256 _reserve1) = getReserves(chainID); require(_reserve1 >= amount0 * diff0, "SwapPair: insuffient liquidity"); // IBoringToken(token1).burn(address(this), amount0 * diff0); reserve1s[chainID] -= amount0 * diff0; totalReserve1s -= amount0 * diff0; // current balance uint256 balance0 = IERC20(token0).balanceOf(address(this)); reserve0 = balance0; emit Swap(msg.sender, amount0, amount0 * diff0, to); } function swapIn(SwapInParams memory params) external override onlyTwoWay onlySupportChainID(params.chainID) { uint256 _reserve0 = reserve0; require(_reserve0 >= params.amount1, "Insuffient liquidity"); require(params.amount1 > 0, "Swap amount should be greater than 0"); IERC20(token0).safeTransfer(params.to, params.remainAmount); if (params.feeAmountFix > 0) { IERC20(token0).safeTransfer(params.feeToDev, params.feeAmountFix); } // IBoringToken(token1).mint(address(this), amount1 * diff0); reserve1s[params.chainID] += params.amount1 * diff0; totalReserve1s += params.amount1 * diff0; // current balance uint256 balance0 = IERC20(token0).balanceOf(address(this)); reserve0 = balance0; emit Swap(msg.sender, params.amount1 * diff0, params.amount1 * diff0, params.to); } modifier onlyTwoWay() { require(msg.sender == twoWay, "SwapPair: only twoWay can invoke it"); _; } modifier onlySupportChainID(uint256 chainID) { require(supportChainids.contains(chainID), "not support chainID"); _; } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"address","name":"_token0","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount0","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount1","type":"uint256"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"Burn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Mint","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountIn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountOut","type":"uint256"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"Swap","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"uint256[]","name":"chainids","type":"uint256[]"}],"name":"addChainIDs","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"lpAmount","type":"uint256"},{"internalType":"address","name":"feeTo","type":"address"},{"internalType":"uint256","name":"feeAmount","type":"uint256"}],"name":"burn","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"lpAmount","type":"uint256"}],"name":"calculateBurn","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"diff0","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"getLPAmount","outputs":[{"internalType":"uint256","name":"lpAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"chainId","type":"uint256"}],"name":"getReserves","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSupportChainIDs","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"mint","outputs":[{"internalType":"uint256","name":"lpAmount","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"chainids","type":"uint256[]"}],"name":"removeChainIDs","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"reserve0","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"reserve1s","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_twoWay","type":"address"}],"name":"setTwoWay","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount1","type":"uint256"},{"internalType":"uint256","name":"feeAmountFix","type":"uint256"},{"internalType":"uint256","name":"remainAmount","type":"uint256"},{"internalType":"address","name":"feeToDev","type":"address"},{"internalType":"uint256","name":"chainID","type":"uint256"}],"internalType":"struct SwapInParams","name":"params","type":"tuple"}],"name":"swapIn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount0","type":"uint256"},{"internalType":"uint256","name":"chainID","type":"uint256"}],"name":"swapOut","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token0","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalReserve1s","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"twoWay","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"update","outputs":[],"stateMutability":"nonpayable","type":"function"}]
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)
000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7000000000000000000000000000000000000000000000000000000000000000954776f576179204c5000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003544c500000000000000000000000000000000000000000000000000000000000
-----Decoded View---------------
Arg [0] : _name (string): TwoWay LP
Arg [1] : _symbol (string): TLP
Arg [2] : _token0 (address): 0xdAC17F958D2ee523a2206206994597C13D831ec7
-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [2] : 000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000009
Arg [4] : 54776f576179204c500000000000000000000000000000000000000000000000
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [6] : 544c500000000000000000000000000000000000000000000000000000000000
Deployed Bytecode Sourcemap
59773:7663:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13608:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;15775:169;;;;;;:::i;:::-;;:::i;:::-;;;6095:14:1;;6088:22;6070:41;;6058:2;6043:18;15775:169:0;6025:92:1;61374:90:0;;;;;;:::i;:::-;;:::i;:::-;;59987:30;;;;;-1:-1:-1;;;;;59987:30:0;;;;;;-1:-1:-1;;;;;5341:32:1;;;5323:51;;5311:2;5296:18;59987:30:0;5278:102:1;14728:108:0;14816:12;;14728:108;;;14878:25:1;;;14866:2;14851:18;14728:108:0;14833:76:1;61472:196:0;;;;;;:::i;:::-;;:::i;16426:492::-;;;;;;:::i;:::-;;:::i;61676:202::-;;;;;;:::i;:::-;;:::i;14570:93::-;;;14653:2;15850:36:1;;15838:2;15823:18;14570:93:0;15805:87:1;17327:215:0;;;;;;:::i;:::-;;:::i;60221:21::-;;;;;-1:-1:-1;;;;;60221:21:0;;;60048:23;;;;;;61886:467;;;;;;:::i;:::-;;:::i;60132:44::-;;;;;;:::i;:::-;;;;;;;;;;;;;;14899:127;;;;;;:::i;:::-;-1:-1:-1;;;;;15000:18:0;14973:7;15000:18;;;;;;;;;;;;14899:127;49893:94;;;:::i;65569:661::-;;;;;;:::i;:::-;;:::i;62761:1176::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;:::i;66238:917::-;;;;;;:::i;:::-;;:::i;60183:29::-;;;;;;49242:87;49315:6;;-1:-1:-1;;;;;49315:6:0;49242:87;;60917:142;;;;;;:::i;:::-;61022:8;;60985:7;61032:18;;;:9;:18;;;;;;;61022:8;;60917:142;;;;;15629:25:1;;;15685:2;15670:18;;15663:34;;;;15602:18;60917:142:0;15584:119:1;13827:104:0;;;:::i;65407:154::-;;;:::i;18045:413::-;;;;;;:::i;:::-;;:::i;15239:175::-;;;;;;:::i;:::-;;:::i;62361:392::-;;;;;;:::i;:::-;;:::i;60251:29::-;;;;;;61067:299;;;:::i;:::-;;;;;;;:::i;63945:1454::-;;;;;;:::i;:::-;;:::i;15477:151::-;;;;;;:::i;:::-;-1:-1:-1;;;;;15593:18:0;;;15566:7;15593:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;15477:151;50142:192;;;;;;:::i;:::-;;:::i;13608:100::-;13662:13;13695:5;13688:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13608:100;:::o;15775:169::-;15858:4;15875:39;11366:10;15898:7;15907:6;15875:8;:39::i;:::-;-1:-1:-1;15932:4:0;15775:169;;;;;:::o;61374:90::-;49315:6;;-1:-1:-1;;;;;49315:6:0;11366:10;49462:23;49454:68;;;;-1:-1:-1;;;49454:68:0;;;;;;;:::i;:::-;;;;;;;;;61440:6:::1;:16:::0;;-1:-1:-1;;;;;;61440:16:0::1;-1:-1:-1::0;;;;;61440:16:0;;;::::1;::::0;;;::::1;::::0;;61374:90::o;61472:196::-;67218:6;;-1:-1:-1;;;;;67218:6:0;67204:10;:20;67196:68;;;;-1:-1:-1;;;67196:68:0;;;;;;;:::i;:::-;61565:9:::1;61560:101;61580:8;:15;61576:1;:19;61560:101;;;61617:32;61637:8;61646:1;61637:11;;;;;;;;:::i;:::-;;;;;;;61617:15;:19;;:32;;;;:::i;:::-;-1:-1:-1::0;61597:3:0;::::1;::::0;::::1;:::i;:::-;;;;61560:101;;;;61472:196:::0;:::o;16426:492::-;16566:4;16583:36;16593:6;16601:9;16612:6;16583:9;:36::i;:::-;-1:-1:-1;;;;;16659:19:0;;16632:24;16659:19;;;:11;:19;;;;;;;;11366:10;16659:33;;;;;;;;16711:26;;;;16703:79;;;;-1:-1:-1;;;16703:79:0;;11068:2:1;16703:79:0;;;11050:21:1;11107:2;11087:18;;;11080:30;11146:34;11126:18;;;11119:62;-1:-1:-1;;;11197:18:1;;;11190:38;11245:19;;16703:79:0;11040:230:1;16703:79:0;16818:57;16827:6;11366:10;16868:6;16849:16;:25;16818:8;:57::i;:::-;16906:4;16899:11;;;16426:492;;;;;;:::o;61676:202::-;67218:6;;-1:-1:-1;;;;;67218:6:0;67204:10;:20;67196:68;;;;-1:-1:-1;;;67196:68:0;;;;;;;:::i;:::-;61772:9:::1;61767:104;61787:8;:15;61783:1;:19;61767:104;;;61824:35;61847:8;61856:1;61847:11;;;;;;;;:::i;:::-;;;;;;;61824:15;:22;;:35;;;;:::i;:::-;-1:-1:-1::0;61804:3:0;::::1;::::0;::::1;:::i;:::-;;;;61767:104;;17327:215:::0;11366:10;17415:4;17464:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;17464:34:0;;;;;;;;;;17415:4;;17432:80;;17455:7;;17464:47;;17501:10;;17464:47;:::i;:::-;17432:8;:80::i;61886:467::-;67218:6;;61950:16;;-1:-1:-1;;;;;67218:6:0;67204:10;:20;67196:68;;;;-1:-1:-1;;;67196:68:0;;;;;;;:::i;:::-;62005:6:::1;::::0;61998:39:::1;::::0;-1:-1:-1;;;61998:39:0;;62031:4:::1;61998:39;::::0;::::1;5323:51:1::0;61979:16:0::1;::::0;-1:-1:-1;;;;;62005:6:0::1;::::0;61998:24:::1;::::0;5296:18:1;;61998:39:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;61979:58;;62048:15;62066:22;62079:8;;62066;:12;;:22;;;;:::i;:::-;62048:40;;62112:20;62124:7;62112:11;:20::i;:::-;62101:31;;62164:1;62153:8;:12;62145:64;;;::::0;-1:-1:-1;;;62145:64:0;;9545:2:1;62145:64:0::1;::::0;::::1;9527:21:1::0;9584:2;9564:18;;;9557:30;9623:34;9603:18;;;9596:62;-1:-1:-1;;;9674:18:1;;;9667:37;9721:19;;62145:64:0::1;9517:229:1::0;62145:64:0::1;62222:19;62228:2;62232:8;62222:5;:19::i;:::-;62282:8;:19:::0;;;62319:26:::1;::::0;14878:25:1;;;62324:10:0::1;::::0;62319:26:::1;::::0;14866:2:1;14851:18;62319:26:0::1;;;;;;;61968:385;;61886:467:::0;;;:::o;49893:94::-;49315:6;;-1:-1:-1;;;;;49315:6:0;11366:10;49462:23;49454:68;;;;-1:-1:-1;;;49454:68:0;;;;;;;:::i;:::-;49958:21:::1;49976:1;49958:9;:21::i;:::-;49893:94::o:0;65569:661::-;67218:6;;-1:-1:-1;;;;;67218:6:0;67204:10;:20;67196:68;;;;-1:-1:-1;;;67196:68:0;;;;;;;:::i;:::-;65714:7;67356:33:::1;:15;65714:7:::0;67356:24:::1;:33::i;:::-;67348:65;;;::::0;-1:-1:-1;;;67348:65:0;;11477:2:1;67348:65:0::1;::::0;::::1;11459:21:1::0;11516:2;11496:18;;;11489:30;-1:-1:-1;;;11535:18:1;;;11528:49;11594:18;;67348:65:0::1;11449:169:1::0;67348:65:0::1;65737:17:::2;61032:18:::0;;;:9;:18;;;;;;65822:5:::2;::::0;65812:15:::2;::::0;:7;:15:::2;:::i;:::-;65799:9;:28;;65791:71;;;::::0;-1:-1:-1;;;65791:71:0;;10709:2:1;65791:71:0::2;::::0;::::2;10691:21:1::0;10748:2;10728:18;;;10721:30;10787:32;10767:18;;;10760:60;10837:18;;65791:71:0::2;10681:180:1::0;65791:71:0::2;65978:5;::::0;65968:15:::2;::::0;:7;:15:::2;:::i;:::-;65946:18;::::0;;;:9:::2;:18;::::0;;;;:37;;:18;;;:37:::2;::::0;;;::::2;:::i;:::-;::::0;;;-1:-1:-1;;66022:5:0::2;::::0;66012:15:::2;::::0;:7;:15:::2;:::i;:::-;65994:14;;:33;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;66094:6:0::2;::::0;66087:39:::2;::::0;-1:-1:-1;;;66087:39:0;;66120:4:::2;66087:39;::::0;::::2;5323:51:1::0;66068:16:0::2;::::0;-1:-1:-1;;;;;66094:6:0::2;::::0;66087:24:::2;::::0;5296:18:1;;66087:39:0::2;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;66068:58;;66150:8;66139;:19;;;;66219:2;-1:-1:-1::0;;;;;66176:46:0::2;66181:10;-1:-1:-1::0;;;;;66176:46:0::2;;66193:7;66212:5;;66202:7;:15;;;;:::i;:::-;66176:46;::::0;;15629:25:1;;;15685:2;15670:18;;15663:34;;;;15602:18;66176:46:0::2;;;;;;;65723:507;;67275:1:::1;65569:661:::0;;;:::o;62761:1176::-;67218:6;;62993:7;;63015:16;;;;-1:-1:-1;;;;;67218:6:0;67204:10;:20;67196:68;;;;-1:-1:-1;;;67196:68:0;;;;;;;:::i;:::-;63091:15:::1;63108:25:::0;63135::::1;63164:23;63178:8;63164:13;:23::i;:::-;63205:6;::::0;63090:97;;-1:-1:-1;63090:97:0;;-1:-1:-1;63090:97:0;-1:-1:-1;;;;;;63205:6:0::1;63198:23;63222:4:::0;63228:19:::1;63238:9:::0;63090:97;63228:19:::1;:::i;:::-;63198:50;::::0;-1:-1:-1;;;;;;63198:50:0::1;::::0;;;;;;-1:-1:-1;;;;;5577:32:1;;;63198:50:0::1;::::0;::::1;5559:51:1::0;5626:18;;;5619:34;5532:18;;63198:50:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;63263:13:0;;63259:87:::1;;63300:6;::::0;63293:41:::1;::::0;-1:-1:-1;;;63293:41:0;;-1:-1:-1;;;;;5577:32:1;;;63293:41:0::1;::::0;::::1;5559:51:1::0;5626:18;;;5619:34;;;63300:6:0;;::::1;::::0;63293:23:::1;::::0;5532:18:1;;63293:41:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;63259:87;63356:19;63391:9:::0;63386:206:::1;63406:8;:15;63402:1;:19;63386:206;;;63461:1;63447:8;63456:1;63447:11;;;;;;;;:::i;:::-;;;;;;;:15;63443:138;;;63509:8;63518:1;63509:11;;;;;;;;:::i;:::-;;;;;;;63483:9;:22;63493:8;63502:1;63493:11;;;;;;;;:::i;:::-;;;;;;;63483:22;;;;;;;;;;;;:37;;;;;;;:::i;:::-;;;;;;;;63554:8;63563:1;63554:11;;;;;;;;:::i;:::-;;;;;;;63539:26;;;;;:::i;:::-;;;63443:138;63423:3:::0;::::1;::::0;::::1;:::i;:::-;;;;63386:206;;;;63604:21;63610:4;63616:8;63604:5;:21::i;:::-;63692:6;::::0;63685:39:::1;::::0;-1:-1:-1;;;63685:39:0;;63718:4:::1;63685:39;::::0;::::1;5323:51:1::0;63666:16:0::1;::::0;-1:-1:-1;;;;;63692:6:0::1;::::0;63685:24:::1;::::0;5296:18:1;;63685:39:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;63666:58;;63774:8;63763;:19;;;;63811:11;63793:14;;:29;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;63840:42:0::1;::::0;;15629:25:1;;;15685:2;15670:18;;15663:34;;;-1:-1:-1;;;;;63840:42:0;::::1;::::0;63845:10:::1;::::0;63840:42:::1;::::0;15602:18:1;63840:42:0::1;;;;;;;-1:-1:-1::0;63901:7:0;;63910:8;;-1:-1:-1;63910:8:0;-1:-1:-1;62761:1176:0;-1:-1:-1;;;;;;;62761:1176:0:o;66238:917::-;67218:6;;-1:-1:-1;;;;;67218:6:0;67204:10;:20;67196:68;;;;-1:-1:-1;;;67196:68:0;;;;;;;:::i;:::-;66330:14:::1;::::0;::::1;::::0;67356:33:::1;:15;66330:14:::0;67356:24:::1;:33::i;:::-;67348:65;;;::::0;-1:-1:-1;;;67348:65:0;;11477:2:1;67348:65:0::1;::::0;::::1;11459:21:1::0;11516:2;11496:18;;;11489:30;-1:-1:-1;;;11535:18:1;;;11528:49;11594:18;;67348:65:0::1;11449:169:1::0;67348:65:0::1;66377:8:::2;::::0;66419:14:::2;::::0;::::2;::::0;66406:27;::::2;;66398:60;;;::::0;-1:-1:-1;;;66398:60:0;;10360:2:1;66398:60:0::2;::::0;::::2;10342:21:1::0;10399:2;10379:18;;;10372:30;-1:-1:-1;;;10418:18:1;;;10411:50;10478:18;;66398:60:0::2;10332:170:1::0;66398:60:0::2;66494:1;66477:6;:14;;;:18;66469:67;;;::::0;-1:-1:-1;;;66469:67:0;;8329:2:1;66469:67:0::2;::::0;::::2;8311:21:1::0;8368:2;8348:18;;;8341:30;8407:34;8387:18;;;8380:62;-1:-1:-1;;;8458:18:1;;;8451:34;8502:19;;66469:67:0::2;8301:226:1::0;66469:67:0::2;66577:9:::0;;66588:19:::2;::::0;::::2;::::0;66556:6:::2;::::0;66549:59:::2;::::0;-1:-1:-1;;;;;66556:6:0;;::::2;::::0;66549:27:::2;:59::i;:::-;66623:19;::::0;::::2;::::0;:23;66619:121:::2;;66691:15;::::0;::::2;::::0;66708:19:::2;::::0;::::2;::::0;66670:6:::2;::::0;66663:65:::2;::::0;-1:-1:-1;;;;;66670:6:0;;::::2;::::0;66663:27:::2;:65::i;:::-;66867:5;;66850:6;:14;;;:22;;;;:::i;:::-;66831:14;::::0;::::2;::::0;66821:25:::2;::::0;;;:9:::2;:25;::::0;;;;:51;;:25;;;:51:::2;::::0;;;::::2;:::i;:::-;::::0;;;-1:-1:-1;;66918:5:0::2;::::0;66901:14:::2;::::0;::::2;::::0;:22:::2;::::0;66918:5;66901:22:::2;:::i;:::-;66883:14;;:40;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;66990:6:0::2;::::0;66983:39:::2;::::0;-1:-1:-1;;;66983:39:0;;67016:4:::2;66983:39;::::0;::::2;5323:51:1::0;66964:16:0::2;::::0;-1:-1:-1;;;;;66990:6:0::2;::::0;66983:24:::2;::::0;5296:18:1;;66983:39:0::2;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;66964:58;;67046:8;67035;:19;;;;67137:6;:9;;;-1:-1:-1::0;;;;;67072:75:0::2;67077:10;-1:-1:-1::0;;;;;67072:75:0::2;;67106:5;;67089:6;:14;;;:22;;;;:::i;:::-;67130:5;;67113:6;:14;;;:22;;;;:::i;:::-;67072:75;::::0;;15629:25:1;;;15685:2;15670:18;;15663:34;;;;15602:18;67072:75:0::2;;;;;;;;66346:809;;67275:1:::1;66238:917:::0;:::o;13827:104::-;13883:13;13916:7;13909:14;;;;;:::i;65407:154::-;67218:6;;-1:-1:-1;;;;;67218:6:0;67204:10;:20;67196:68;;;;-1:-1:-1;;;67196:68:0;;;;;;;:::i;:::-;65491:6:::1;::::0;65484:39:::1;::::0;-1:-1:-1;;;65484:39:0;;65517:4:::1;65484:39;::::0;::::1;5323:51:1::0;65465:16:0::1;::::0;-1:-1:-1;;;;;65491:6:0::1;::::0;65484:24:::1;::::0;5296:18:1;;65484:39:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;65534:8;:19:::0;-1:-1:-1;65407:154:0:o;18045:413::-;11366:10;18138:4;18182:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;18182:34:0;;;;;;;;;;18235:35;;;;18227:85;;;;-1:-1:-1;;;18227:85:0;;14168:2:1;18227:85:0;;;14150:21:1;14207:2;14187:18;;;14180:30;14246:34;14226:18;;;14219:62;-1:-1:-1;;;14297:18:1;;;14290:35;14342:19;;18227:85:0;14140:227:1;18227:85:0;18348:67;11366:10;18371:7;18399:15;18380:16;:34;18348:8;:67::i;:::-;-1:-1:-1;18446:4:0;;18045:413;-1:-1:-1;;;18045:413:0:o;15239:175::-;15325:4;15342:42;11366:10;15366:9;15377:6;15342:9;:42::i;62361:392::-;62419:16;62448:20;62480:5;;62471:6;:14;;;;:::i;:::-;62448:37;;62496:17;62527:5;;62516:8;;:16;;;;:::i;:::-;62496:36;;62543:13;62559;14816:12;;;14728:108;62559:13;62543:29;-1:-1:-1;62587:10:0;62583:163;;62625:12;62614:23;;62583:163;;;62724:9;62707:14;;:26;;;;:::i;:::-;62682:20;62697:5;62682:12;:20;:::i;:::-;62681:53;;;;:::i;:::-;62670:64;;62583:163;62437:316;;;62361:392;;;:::o;61067:299::-;61119:16;61148:22;61187:24;:15;:22;:24::i;:::-;61173:39;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;61173:39:0;;61148:64;;61228:6;61223:110;61240:24;:15;:22;:24::i;:::-;61236:1;:28;61223:110;;;61300:21;:15;61319:1;61300:18;:21::i;:::-;61286:8;61295:1;61286:11;;;;;;;;:::i;:::-;;;;;;;;;;:35;61266:3;;;;:::i;:::-;;;;61223:110;;;-1:-1:-1;61350:8:0;61067:299;-1:-1:-1;61067:299:0:o;63945:1454::-;64048:7;64070:16;64101;64145:17;64176:5;;64165:8;;:16;;;;:::i;:::-;64145:36;;64192:20;64215:13;14816:12;;;14728:108;64215:13;64192:36;;64239:13;64299:12;64280:14;;64268:9;:26;;;;:::i;:::-;64256:39;;:8;:39;:::i;:::-;64255:56;;;;:::i;:::-;64239:72;;64337:9;64328:5;:18;64324:1068;;64363:15;64389:5;;64381;:13;;;;:::i;:::-;64437:16;;;64409:25;64437:16;;;;;;64495;;;;;;;;;64363:31;;-1:-1:-1;64437:16:0;;-1:-1:-1;64437:16:0;-1:-1:-1;64526:35:0;;-1:-1:-1;;;;64526:35:0;64324:1068;64594:14;64611:17;64619:9;64611:5;:17;:::i;:::-;64594:34;;64643:21;64667:24;:15;:22;:24::i;:::-;64643:48;;64706:25;64748:13;64734:28;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;64734:28:0;;64706:56;;64777:24;64818:13;64804:28;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;64804:28:0;;64777:55;;64852:9;64847:483;64867:13;64863:1;:17;64847:483;;;64906:15;64924:21;:15;64943:1;64924:18;:21::i;:::-;64968:18;;;;:9;:18;;;;;;64906:39;;-1:-1:-1;64968:28:0;-1:-1:-1;64964:351:0;;65035:7;65021:8;65030:1;65021:11;;;;;;;;:::i;:::-;;;;;;:21;;;;;65078:6;65065:7;65073:1;65065:10;;;;;;;;:::i;:::-;;;;;;:19;;;;;65107:5;;;64964:351;65175:7;65161:8;65170:1;65161:11;;;;;;;;:::i;:::-;;;;;;:21;;;;;65218:9;:18;65228:7;65218:18;;;;;;;;;;;;65205:7;65213:1;65205:10;;;;;;;;:::i;:::-;;;;;;:31;;;;;65277:9;:18;65287:7;65277:18;;;;;;;;;;;;65268:6;:27;;;;:::i;:::-;65259:36;;-1:-1:-1;64882:3:0;;;;:::i;:::-;;;;64847:483;;;-1:-1:-1;65352:8:0;;;-1:-1:-1;65362:8:0;;-1:-1:-1;65372:7:0;-1:-1:-1;65344:36:0;;-1:-1:-1;;;;;65344:36:0;63945:1454;;;;;;:::o;50142:192::-;49315:6;;-1:-1:-1;;;;;49315:6:0;11366:10;49462:23;49454:68;;;;-1:-1:-1;;;49454:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;50231:22:0;::::1;50223:73;;;::::0;-1:-1:-1;;;50223:73:0;;7519:2:1;50223:73:0::1;::::0;::::1;7501:21:1::0;7558:2;7538:18;;;7531:30;7597:34;7577:18;;;7570:62;-1:-1:-1;;;7648:18:1;;;7641:36;7694:19;;50223:73:0::1;7491:228:1::0;50223:73:0::1;50307:19;50317:8;50307:9;:19::i;:::-;50142:192:::0;:::o;21729:380::-;-1:-1:-1;;;;;21865:19:0;;21857:68;;;;-1:-1:-1;;;21857:68:0;;12994:2:1;21857:68:0;;;12976:21:1;13033:2;13013:18;;;13006:30;13072:34;13052:18;;;13045:62;-1:-1:-1;;;13123:18:1;;;13116:34;13167:19;;21857:68:0;12966:226:1;21857:68:0;-1:-1:-1;;;;;21944:21:0;;21936:68;;;;-1:-1:-1;;;21936:68:0;;7926:2:1;21936:68:0;;;7908:21:1;7965:2;7945:18;;;7938:30;8004:34;7984:18;;;7977:62;-1:-1:-1;;;8055:18:1;;;8048:32;8097:19;;21936:68:0;7898:224:1;21936:68:0;-1:-1:-1;;;;;22017:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;22069:32;;14878:25:1;;;22069:32:0;;14851:18:1;22069:32:0;;;;;;;;21729:380;;;:::o;46022:131::-;46089:4;46113:32;46118:3;46138:5;46113:4;:32::i;18948:733::-;-1:-1:-1;;;;;19088:20:0;;19080:70;;;;-1:-1:-1;;;19080:70:0;;12588:2:1;19080:70:0;;;12570:21:1;12627:2;12607:18;;;12600:30;12666:34;12646:18;;;12639:62;-1:-1:-1;;;12717:18:1;;;12710:35;12762:19;;19080:70:0;12560:227:1;19080:70:0;-1:-1:-1;;;;;19169:23:0;;19161:71;;;;-1:-1:-1;;;19161:71:0;;6712:2:1;19161:71:0;;;6694:21:1;6751:2;6731:18;;;6724:30;6790:34;6770:18;;;6763:62;-1:-1:-1;;;6841:18:1;;;6834:33;6884:19;;19161:71:0;6684:225:1;19161:71:0;-1:-1:-1;;;;;19329:17:0;;19305:21;19329:17;;;;;;;;;;;19365:23;;;;19357:74;;;;-1:-1:-1;;;19357:74:0;;9138:2:1;19357:74:0;;;9120:21:1;9177:2;9157:18;;;9150:30;9216:34;9196:18;;;9189:62;-1:-1:-1;;;9267:18:1;;;9260:36;9313:19;;19357:74:0;9110:228:1;19357:74:0;-1:-1:-1;;;;;19467:17:0;;;:9;:17;;;;;;;;;;;19487:22;;;19467:42;;19531:20;;;;;;;;:30;;19503:6;;19467:9;19531:30;;19503:6;;19531:30;:::i;:::-;;;;;;;;19596:9;-1:-1:-1;;;;;19579:35:0;19588:6;-1:-1:-1;;;;;19579:35:0;;19607:6;19579:35;;;;14878:25:1;;14866:2;14851:18;;14833:76;19627:46:0;19069:612;18948:733;;;:::o;46329:137::-;46399:4;46423:35;46431:3;46451:5;46423:7;:35::i;3274:98::-;3332:7;3359:5;3363:1;3359;:5;:::i;19968:399::-;-1:-1:-1;;;;;20052:21:0;;20044:65;;;;-1:-1:-1;;;20044:65:0;;14574:2:1;20044:65:0;;;14556:21:1;14613:2;14593:18;;;14586:30;14652:33;14632:18;;;14625:61;14703:18;;20044:65:0;14546:181:1;20044:65:0;20200:6;20184:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;20217:18:0;;:9;:18;;;;;;;;;;:28;;20239:6;;20217:9;:28;;20239:6;;20217:28;:::i;:::-;;;;-1:-1:-1;;20261:37:0;;14878:25:1;;;-1:-1:-1;;;;;20261:37:0;;;20278:1;;20261:37;;14866:2:1;14851:18;20261:37:0;;;;;;;61560:101:::1;61472:196:::0;:::o;50342:173::-;50417:6;;;-1:-1:-1;;;;;50434:17:0;;;-1:-1:-1;;;;;;50434:17:0;;;;;;;50467:40;;50417:6;;;50434:17;50417:6;;50467:40;;50398:16;;50467:40;50387:128;50342:173;:::o;46552:146::-;46629:4;39612:19;;;:12;;;:19;;;;;;:24;;46653:37;39515:129;20700:591;-1:-1:-1;;;;;20784:21:0;;20776:67;;;;-1:-1:-1;;;20776:67:0;;12186:2:1;20776:67:0;;;12168:21:1;12225:2;12205:18;;;12198:30;12264:34;12244:18;;;12237:62;-1:-1:-1;;;12315:18:1;;;12308:31;12356:19;;20776:67:0;12158:223:1;20776:67:0;-1:-1:-1;;;;;20943:18:0;;20918:22;20943:18;;;;;;;;;;;20980:24;;;;20972:71;;;;-1:-1:-1;;;20972:71:0;;7116:2:1;20972:71:0;;;7098:21:1;7155:2;7135:18;;;7128:30;7194:34;7174:18;;;7167:62;-1:-1:-1;;;7245:18:1;;;7238:32;7287:19;;20972:71:0;7088:224:1;20972:71:0;-1:-1:-1;;;;;21079:18:0;;:9;:18;;;;;;;;;;21100:23;;;21079:44;;21145:12;:22;;21117:6;;21079:9;21145:22;;21117:6;;21145:22;:::i;:::-;;;;-1:-1:-1;;21185:37:0;;14878:25:1;;;21211:1:0;;-1:-1:-1;;;;;21185:37:0;;;;;14866:2:1;14851:18;21185:37:0;14833:76:1;21235:48:0;20765:526;20700:591;;:::o;32367:211::-;32511:58;;;-1:-1:-1;;;;;5577:32:1;;32511:58:0;;;5559:51:1;5626:18;;;;5619:34;;;32511:58:0;;;;;;;;;;5532:18:1;;;;32511:58:0;;;;;;;;-1:-1:-1;;;;;32511:58:0;-1:-1:-1;;;32511:58:0;;;32484:86;;32504:5;;32484:19;:86::i;46784:114::-;46844:7;46871:19;46879:3;39813:18;;39730:109;47252:137;47323:7;47358:22;47362:3;47374:5;47358:3;:22::i;37419:414::-;37482:4;39612:19;;;:12;;;:19;;;;;;37499:327;;-1:-1:-1;37542:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;37725:18;;37703:19;;;:12;;;:19;;;;;;:40;;;;37758:11;;37499:327;-1:-1:-1;37809:5:0;37802:12;;38009:1420;38075:4;38214:19;;;:12;;;:19;;;;;;38250:15;;38246:1176;;38625:21;38649:14;38662:1;38649:10;:14;:::i;:::-;38698:18;;38625:38;;-1:-1:-1;38678:17:0;;38698:22;;38719:1;;38698:22;:::i;:::-;38678:42;;38754:13;38741:9;:26;38737:405;;38788:17;38808:3;:11;;38820:9;38808:22;;;;;;;;:::i;:::-;;;;;;;;;38788:42;;38962:9;38933:3;:11;;38945:13;38933:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;39047:23;;;:12;;;:23;;;;;:36;;;38737:405;39223:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;39318:3;:12;;:19;39331:5;39318:19;;;;;;;;;;;39311:26;;;39361:4;39354:11;;;;;;;38246:1176;39405:5;39398:12;;;;;34940:716;35364:23;35390:69;35418:4;35390:69;;;;;;;;;;;;;;;;;35398:5;-1:-1:-1;;;;;35390:27:0;;;:69;;;;;:::i;:::-;35474:17;;35364:95;;-1:-1:-1;35474:21:0;35470:179;;35571:10;35560:30;;;;;;;;;;;;:::i;:::-;35552:85;;;;-1:-1:-1;;;35552:85:0;;13757:2:1;35552:85:0;;;13739:21:1;13796:2;13776:18;;;13769:30;13835:34;13815:18;;;13808:62;-1:-1:-1;;;13886:18:1;;;13879:40;13936:19;;35552:85:0;13729:232:1;40193:120:0;40260:7;40287:3;:11;;40299:5;40287:18;;;;;;;;:::i;:::-;;;;;;;;;40280:25;;40193:120;;;;:::o;27178:229::-;27315:12;27347:52;27369:6;27377:4;27383:1;27386:12;27347:21;:52::i;:::-;27340:59;27178:229;-1:-1:-1;;;;27178:229:0:o;28298:510::-;28468:12;28526:5;28501:21;:30;;28493:81;;;;-1:-1:-1;;;28493:81:0;;9953:2:1;28493:81:0;;;9935:21:1;9992:2;9972:18;;;9965:30;10031:34;10011:18;;;10004:62;-1:-1:-1;;;10082:18:1;;;10075:36;10128:19;;28493:81:0;9925:228:1;28493:81:0;24695:20;;28585:60;;;;-1:-1:-1;;;28585:60:0;;13399:2:1;28585:60:0;;;13381:21:1;13438:2;13418:18;;;13411:30;13477:31;13457:18;;;13450:59;13526:18;;28585:60:0;13371:179:1;28585:60:0;28659:12;28673:23;28700:6;-1:-1:-1;;;;;28700:11:0;28719:5;28726:4;28700:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28658:73;;;;28749:51;28766:7;28775:10;28787:12;28749:16;:51::i;:::-;28742:58;28298:510;-1:-1:-1;;;;;;;28298:510:0:o;30984:712::-;31134:12;31163:7;31159:530;;;-1:-1:-1;31194:10:0;31187:17;;31159:530;31308:17;;:21;31304:374;;31506:10;31500:17;31567:15;31554:10;31550:2;31546:19;31539:44;31304:374;31649:12;31642:20;;-1:-1:-1;;;31642:20:0;;;;;;;;:::i;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:2;;177:1;174;167:12;111:2;63:124;;;:::o;192:186::-;251:6;304:2;292:9;283:7;279:23;275:32;272:2;;;320:1;317;310:12;272:2;343:29;362:9;343:29;:::i;383:260::-;451:6;459;512:2;500:9;491:7;487:23;483:32;480:2;;;528:1;525;518:12;480:2;551:29;570:9;551:29;:::i;:::-;541:39;;599:38;633:2;622:9;618:18;599:38;:::i;:::-;589:48;;470:173;;;;;:::o;648:328::-;725:6;733;741;794:2;782:9;773:7;769:23;765:32;762:2;;;810:1;807;800:12;762:2;833:29;852:9;833:29;:::i;:::-;823:39;;881:38;915:2;904:9;900:18;881:38;:::i;:::-;871:48;;966:2;955:9;951:18;938:32;928:42;;752:224;;;;;:::o;981:472::-;1076:6;1084;1092;1100;1108;1161:3;1149:9;1140:7;1136:23;1132:33;1129:2;;;1178:1;1175;1168:12;1129:2;1201:29;1220:9;1201:29;:::i;:::-;1191:39;;1249:38;1283:2;1272:9;1268:18;1249:38;:::i;:::-;1239:48;;1334:2;1323:9;1319:18;1306:32;1296:42;;1357:38;1391:2;1380:9;1376:18;1357:38;:::i;:::-;1119:334;;;;-1:-1:-1;1119:334:1;;1442:3;1427:19;1414:33;;1119:334;-1:-1:-1;;1119:334:1:o;1458:254::-;1526:6;1534;1587:2;1575:9;1566:7;1562:23;1558:32;1555:2;;;1603:1;1600;1593:12;1555:2;1626:29;1645:9;1626:29;:::i;:::-;1616:39;1702:2;1687:18;;;;1674:32;;-1:-1:-1;;;1545:167:1:o;1717:322::-;1794:6;1802;1810;1863:2;1851:9;1842:7;1838:23;1834:32;1831:2;;;1879:1;1876;1869:12;1831:2;1902:29;1921:9;1902:29;:::i;:::-;1892:39;1978:2;1963:18;;1950:32;;-1:-1:-1;2029:2:1;2014:18;;;2001:32;;1821:218;-1:-1:-1;;;1821:218:1:o;2044:957::-;2128:6;2159:2;2202;2190:9;2181:7;2177:23;2173:32;2170:2;;;2218:1;2215;2208:12;2170:2;2258:9;2245:23;2287:18;2328:2;2320:6;2317:14;2314:2;;;2344:1;2341;2334:12;2314:2;2382:6;2371:9;2367:22;2357:32;;2427:7;2420:4;2416:2;2412:13;2408:27;2398:2;;2449:1;2446;2439:12;2398:2;2485;2472:16;2507:2;2503;2500:10;2497:2;;;2513:18;;:::i;:::-;2559:2;2556:1;2552:10;2542:20;;2582:28;2606:2;2602;2598:11;2582:28;:::i;:::-;2644:15;;;2675:12;;;;2707:11;;;2737;;;2733:20;;2730:33;-1:-1:-1;2727:2:1;;;2776:1;2773;2766:12;2727:2;2798:1;2789:10;;2808:163;2822:2;2819:1;2816:9;2808:163;;;2879:17;;2867:30;;2840:1;2833:9;;;;;2917:12;;;;2949;;2808:163;;;-1:-1:-1;2990:5:1;2139:862;-1:-1:-1;;;;;;;;2139:862:1:o;3006:277::-;3073:6;3126:2;3114:9;3105:7;3101:23;3097:32;3094:2;;;3142:1;3139;3132:12;3094:2;3174:9;3168:16;3227:5;3220:13;3213:21;3206:5;3203:32;3193:2;;3249:1;3246;3239:12;3288:791;3377:6;3430:3;3418:9;3409:7;3405:23;3401:33;3398:2;;;3447:1;3444;3437:12;3398:2;3480;3474:9;3522:3;3514:6;3510:16;3592:6;3580:10;3577:22;3556:18;3544:10;3541:34;3538:62;3535:2;;;3603:18;;:::i;:::-;3639:2;3632:22;3678:29;3697:9;3678:29;:::i;:::-;3670:6;3663:45;3769:2;3758:9;3754:18;3741:32;3736:2;3728:6;3724:15;3717:57;3835:2;3824:9;3820:18;3807:32;3802:2;3794:6;3790:15;3783:57;3901:2;3890:9;3886:18;3873:32;3868:2;3860:6;3856:15;3849:57;3940:39;3974:3;3963:9;3959:19;3940:39;:::i;:::-;3934:3;3926:6;3922:16;3915:65;4042:3;4031:9;4027:19;4014:33;4008:3;4000:6;3996:16;3989:59;4067:6;4057:16;;;3388:691;;;;:::o;4084:180::-;4143:6;4196:2;4184:9;4175:7;4171:23;4167:32;4164:2;;;4212:1;4209;4202:12;4164:2;-1:-1:-1;4235:23:1;;4154:110;-1:-1:-1;4154:110:1:o;4269:184::-;4339:6;4392:2;4380:9;4371:7;4367:23;4363:32;4360:2;;;4408:1;4405;4398:12;4360:2;-1:-1:-1;4431:16:1;;4350:103;-1:-1:-1;4350:103:1:o;4458:435::-;4511:3;4549:5;4543:12;4576:6;4571:3;4564:19;4602:4;4631:2;4626:3;4622:12;4615:19;;4668:2;4661:5;4657:14;4689:1;4699:169;4713:6;4710:1;4707:13;4699:169;;;4774:13;;4762:26;;4808:12;;;;4843:15;;;;4735:1;4728:9;4699:169;;;-1:-1:-1;4884:3:1;;4519:374;-1:-1:-1;;;;;4519:374:1:o;4898:274::-;5027:3;5065:6;5059:13;5081:53;5127:6;5122:3;5115:4;5107:6;5103:17;5081:53;:::i;:::-;5150:16;;;;;5035:137;-1:-1:-1;;5035:137:1:o;5664:261::-;5843:2;5832:9;5825:21;5806:4;5863:56;5915:2;5904:9;5900:18;5892:6;5863:56;:::i;6122:383::-;6271:2;6260:9;6253:21;6234:4;6303:6;6297:13;6346:6;6341:2;6330:9;6326:18;6319:34;6362:66;6421:6;6416:2;6405:9;6401:18;6396:2;6388:6;6384:15;6362:66;:::i;:::-;6489:2;6468:15;-1:-1:-1;;6464:29:1;6449:45;;;;6496:2;6445:54;;6243:262;-1:-1:-1;;6243:262:1:o;8532:399::-;8734:2;8716:21;;;8773:2;8753:18;;;8746:30;8812:34;8807:2;8792:18;;8785:62;-1:-1:-1;;;8878:2:1;8863:18;;8856:33;8921:3;8906:19;;8706:225::o;11623:356::-;11825:2;11807:21;;;11844:18;;;11837:30;11903:34;11898:2;11883:18;;11876:62;11970:2;11955:18;;11797:182::o;14914:536::-;15199:6;15188:9;15181:25;15242:2;15237;15226:9;15222:18;15215:30;15162:4;15268:56;15320:2;15309:9;15305:18;15297:6;15268:56;:::i;:::-;15372:9;15364:6;15360:22;15355:2;15344:9;15340:18;15333:50;15400:44;15437:6;15429;15400:44;:::i;:::-;15392:52;15171:279;-1:-1:-1;;;;;;15171:279:1:o;15897:275::-;15968:2;15962:9;16033:2;16014:13;;-1:-1:-1;;16010:27:1;15998:40;;16068:18;16053:34;;16089:22;;;16050:62;16047:2;;;16115:18;;:::i;:::-;16151:2;16144:22;15942:230;;-1:-1:-1;15942:230:1:o;16177:128::-;16217:3;16248:1;16244:6;16241:1;16238:13;16235:2;;;16254:18;;:::i;:::-;-1:-1:-1;16290:9:1;;16225:80::o;16310:217::-;16350:1;16376;16366:2;;16420:10;16415:3;16411:20;16408:1;16401:31;16455:4;16452:1;16445:15;16483:4;16480:1;16473:15;16366:2;-1:-1:-1;16512:9:1;;16356:171::o;16532:168::-;16572:7;16638:1;16634;16630:6;16626:14;16623:1;16620:21;16615:1;16608:9;16601:17;16597:45;16594:2;;;16645:18;;:::i;:::-;-1:-1:-1;16685:9:1;;16584:116::o;16705:125::-;16745:4;16773:1;16770;16767:8;16764:2;;;16778:18;;:::i;:::-;-1:-1:-1;16815:9:1;;16754:76::o;16835:258::-;16907:1;16917:113;16931:6;16928:1;16925:13;16917:113;;;17007:11;;;17001:18;16988:11;;;16981:39;16953:2;16946:10;16917:113;;;17048:6;17045:1;17042:13;17039:2;;;-1:-1:-1;;17083:1:1;17065:16;;17058:27;16888:205::o;17098:380::-;17177:1;17173:12;;;;17220;;;17241:2;;17295:4;17287:6;17283:17;17273:27;;17241:2;17348;17340:6;17337:14;17317:18;17314:38;17311:2;;;17394:10;17389:3;17385:20;17382:1;17375:31;17429:4;17426:1;17419:15;17457:4;17454:1;17447:15;17483:135;17522:3;-1:-1:-1;;17543:17:1;;17540:2;;;17563:18;;:::i;:::-;-1:-1:-1;17610:1:1;17599:13;;17530:88::o;17623:127::-;17684:10;17679:3;17675:20;17672:1;17665:31;17715:4;17712:1;17705:15;17739:4;17736:1;17729:15;17755:127;17816:10;17811:3;17807:20;17804:1;17797:31;17847:4;17844:1;17837:15;17871:4;17868:1;17861:15;17887:127;17948:10;17943:3;17939:20;17936:1;17929:31;17979:4;17976:1;17969:15;18003:4;18000:1;17993:15;18019:127;18080:10;18075:3;18071:20;18068:1;18061:31;18111:4;18108:1;18101:15;18135:4;18132:1;18125:15
Swarm Source
ipfs://b51d3b673ff8d60ee4593078d24865e35883b17920789294cb3e332b435fbf81
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ 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.