Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 1 from a total of 1 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
Value | ||||
---|---|---|---|---|---|---|---|---|---|
0x60806040 | 12424279 | 1051 days ago | IN | Create: RatioPCVController | 0 ETH | 0.11312715 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
RatioPCVController
Compiler Version
v0.6.6+commit.6c089d02
Contract Source Code (Solidity Standard Json-Input format)
pragma solidity ^0.6.0; pragma experimental ABIEncoderV2; import "../refs/CoreRef.sol"; import "./IPCVDeposit.sol"; /// @title a PCV controller for moving a ratio of the total value in the PCV deposit /// @author Fei Protocol contract RatioPCVController is CoreRef { uint256 public constant BASIS_POINTS_GRANULARITY = 10_000; event Withdraw(address indexed pcvDeposit, address indexed to, uint256 amount); /// @notice PCV controller constructor /// @param _core Fei Core for reference constructor( address _core ) public CoreRef(_core) {} /// @notice withdraw tokens from the input PCV deposit in basis points terms /// @param to the address to send PCV to function withdrawRatio(IPCVDeposit pcvDeposit, address to, uint256 basisPoints) public onlyPCVController whenNotPaused { require(basisPoints <= BASIS_POINTS_GRANULARITY, "RatioPCVController: basisPoints too high"); uint256 amount = pcvDeposit.totalValue() * basisPoints / BASIS_POINTS_GRANULARITY; require(amount != 0, "RatioPCVController: no value to withdraw"); pcvDeposit.withdraw(to, amount); emit Withdraw(address(pcvDeposit), to, amount); } }
pragma solidity ^0.6.0; pragma experimental ABIEncoderV2; import "./ICoreRef.sol"; import "@openzeppelin/contracts/utils/Pausable.sol"; import "@openzeppelin/contracts/utils/Address.sol"; /// @title A Reference to Core /// @author Fei Protocol /// @notice defines some modifiers and utilities around interacting with Core abstract contract CoreRef is ICoreRef, Pausable { ICore private _core; /// @notice CoreRef constructor /// @param core Fei Core to reference constructor(address core) public { _core = ICore(core); } modifier ifMinterSelf() { if (_core.isMinter(address(this))) { _; } } modifier ifBurnerSelf() { if (_core.isBurner(address(this))) { _; } } modifier onlyMinter() { require(_core.isMinter(msg.sender), "CoreRef: Caller is not a minter"); _; } modifier onlyBurner() { require(_core.isBurner(msg.sender), "CoreRef: Caller is not a burner"); _; } modifier onlyPCVController() { require( _core.isPCVController(msg.sender), "CoreRef: Caller is not a PCV controller" ); _; } modifier onlyGovernor() { require( _core.isGovernor(msg.sender), "CoreRef: Caller is not a governor" ); _; } modifier onlyGuardianOrGovernor() { require( _core.isGovernor(msg.sender) || _core.isGuardian(msg.sender), "CoreRef: Caller is not a guardian or governor" ); _; } modifier onlyFei() { require(msg.sender == address(fei()), "CoreRef: Caller is not FEI"); _; } modifier onlyGenesisGroup() { require( msg.sender == _core.genesisGroup(), "CoreRef: Caller is not GenesisGroup" ); _; } modifier postGenesis() { require( _core.hasGenesisGroupCompleted(), "CoreRef: Still in Genesis Period" ); _; } modifier nonContract() { require(!Address.isContract(msg.sender), "CoreRef: Caller is a contract"); _; } /// @notice set new Core reference address /// @param core the new core address function setCore(address core) external override onlyGovernor { _core = ICore(core); emit CoreUpdate(core); } /// @notice set pausable methods to paused function pause() public override onlyGuardianOrGovernor { _pause(); } /// @notice set pausable methods to unpaused function unpause() public override onlyGuardianOrGovernor { _unpause(); } /// @notice address of the Core contract referenced /// @return ICore implementation address function core() public view override returns (ICore) { return _core; } /// @notice address of the Fei contract referenced by Core /// @return IFei implementation address function fei() public view override returns (IFei) { return _core.fei(); } /// @notice address of the Tribe contract referenced by Core /// @return IERC20 implementation address function tribe() public view override returns (IERC20) { return _core.tribe(); } /// @notice fei balance of contract /// @return fei amount held function feiBalance() public view override returns (uint256) { return fei().balanceOf(address(this)); } /// @notice tribe balance of contract /// @return tribe amount held function tribeBalance() public view override returns (uint256) { return tribe().balanceOf(address(this)); } function _burnFeiHeld() internal { fei().burn(feiBalance()); } function _mintFei(uint256 amount) internal { fei().mint(address(this), amount); } }
pragma solidity ^0.6.0; pragma experimental ABIEncoderV2; import "../core/ICore.sol"; /// @title CoreRef interface /// @author Fei Protocol interface ICoreRef { // ----------- Events ----------- event CoreUpdate(address indexed _core); // ----------- Governor only state changing api ----------- function setCore(address core) external; function pause() external; function unpause() external; // ----------- Getters ----------- function core() external view returns (ICore); function fei() external view returns (IFei); function tribe() external view returns (IERC20); function feiBalance() external view returns (uint256); function tribeBalance() external view returns (uint256); }
pragma solidity ^0.6.0; pragma experimental ABIEncoderV2; import "./IPermissions.sol"; import "../token/IFei.sol"; /// @title Core Interface /// @author Fei Protocol interface ICore is IPermissions { // ----------- Events ----------- event FeiUpdate(address indexed _fei); event TribeUpdate(address indexed _tribe); event GenesisGroupUpdate(address indexed _genesisGroup); event TribeAllocation(address indexed _to, uint256 _amount); event GenesisPeriodComplete(uint256 _timestamp); // ----------- Governor only state changing api ----------- function init() external; // ----------- Governor only state changing api ----------- function setFei(address token) external; function setTribe(address token) external; function setGenesisGroup(address _genesisGroup) external; function allocateTribe(address to, uint256 amount) external; // ----------- Genesis Group only state changing api ----------- function completeGenesisGroup() external; // ----------- Getters ----------- function fei() external view returns (IFei); function tribe() external view returns (IERC20); function genesisGroup() external view returns (address); function hasGenesisGroupCompleted() external view returns (bool); }
pragma solidity ^0.6.0; pragma experimental ABIEncoderV2; /// @title Permissions interface /// @author Fei Protocol interface IPermissions { // ----------- Governor only state changing api ----------- function createRole(bytes32 role, bytes32 adminRole) external; function grantMinter(address minter) external; function grantBurner(address burner) external; function grantPCVController(address pcvController) external; function grantGovernor(address governor) external; function grantGuardian(address guardian) external; function revokeMinter(address minter) external; function revokeBurner(address burner) external; function revokePCVController(address pcvController) external; function revokeGovernor(address governor) external; function revokeGuardian(address guardian) external; // ----------- Revoker only state changing api ----------- function revokeOverride(bytes32 role, address account) external; // ----------- Getters ----------- function isBurner(address _address) external view returns (bool); function isMinter(address _address) external view returns (bool); function isGovernor(address _address) external view returns (bool); function isGuardian(address _address) external view returns (bool); function isPCVController(address _address) external view returns (bool); }
pragma solidity ^0.6.2; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; /// @title FEI stablecoin interface /// @author Fei Protocol interface IFei is IERC20 { // ----------- Events ----------- event Minting( address indexed _to, address indexed _minter, uint256 _amount ); event Burning( address indexed _to, address indexed _burner, uint256 _amount ); event IncentiveContractUpdate( address indexed _incentivized, address indexed _incentiveContract ); // ----------- State changing api ----------- function burn(uint256 amount) external; function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; // ----------- Burner only state changing api ----------- function burnFrom(address account, uint256 amount) external; // ----------- Minter only state changing api ----------- function mint(address account, uint256 amount) external; // ----------- Governor only state changing api ----------- function setIncentiveContract(address account, address incentive) external; // ----------- Getters ----------- function incentiveContract(address account) external view returns (address); }
pragma solidity ^0.6.2; /// @title a PCV Deposit interface /// @author Fei Protocol interface IPCVDeposit { // ----------- Events ----------- event Deposit(address indexed _from, uint256 _amount); event Withdrawal( address indexed _caller, address indexed _to, uint256 _amount ); // ----------- State changing api ----------- function deposit(uint256 amount) external payable; // ----------- PCV Controller only state changing api ----------- function withdraw(address to, uint256 amount) external; // ----------- Getters ----------- function totalValue() external view returns (uint256); }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; import "./Context.sol"; /** * @dev Contract module which allows children to implement an emergency stop * mechanism that can be triggered by an authorized account. * * This module is used through inheritance. It will make available the * modifiers `whenNotPaused` and `whenPaused`, which can be applied to * the functions of your contract. Note that they will not be pausable by * simply including this module, only once the modifiers are put in place. */ abstract contract Pausable is Context { /** * @dev Emitted when the pause is triggered by `account`. */ event Paused(address account); /** * @dev Emitted when the pause is lifted by `account`. */ event Unpaused(address account); bool private _paused; /** * @dev Initializes the contract in unpaused state. */ constructor () internal { _paused = false; } /** * @dev Returns true if the contract is paused, and false otherwise. */ function paused() public view virtual returns (bool) { return _paused; } /** * @dev Modifier to make a function callable only when the contract is not paused. * * Requirements: * * - The contract must not be paused. */ modifier whenNotPaused() { require(!paused(), "Pausable: paused"); _; } /** * @dev Modifier to make a function callable only when the contract is paused. * * Requirements: * * - The contract must be paused. */ modifier whenPaused() { require(paused(), "Pausable: not paused"); _; } /** * @dev Triggers stopped state. * * Requirements: * * - The contract must not be paused. */ function _pause() internal virtual whenNotPaused { _paused = true; emit Paused(_msgSender()); } /** * @dev Returns to normal state. * * Requirements: * * - The contract must be paused. */ function _unpause() internal virtual whenPaused { _paused = false; emit Unpaused(_msgSender()); } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /* * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with GSN meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.2 <0.8.0; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain`call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @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"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } }
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); }
{ "metadata": { "useLiteralContent": true }, "optimizer": { "enabled": true, "runs": 200 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "abi" ] } } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_core","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_core","type":"address"}],"name":"CoreUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pcvDeposit","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"BASIS_POINTS_GRANULARITY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"core","outputs":[{"internalType":"contract ICore","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"fei","outputs":[{"internalType":"contract IFei","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feiBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"core","type":"address"}],"name":"setCore","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"tribe","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tribeBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IPCVDeposit","name":"pcvDeposit","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"basisPoints","type":"uint256"}],"name":"withdrawRatio","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)
0000000000000000000000008d5ed43dca8c2f7dfb20cf7b53cc7e593635d7b9
-----Decoded View---------------
Arg [0] : _core (address): 0x8d5ED43dCa8C2F7dFB20CF7b53CC7E593635d7b9
-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000008d5ed43dca8c2f7dfb20cf7b53cc7e593635d7b9
Deployed Bytecode Sourcemap
228:1004:3:-:0;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;228:1004:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;9;2:12;2605:85:4;;;:::i;:::-;;711:519:3;;;;;;;;;:::i;1052:84:10:-;;;:::i;:::-;;;;;;;;;;;;;;;;278:57:3;;;:::i;:::-;;;;;;;;3562:119:4;;;:::i;2287:129::-;;;;;;;;;:::i;2469:81::-;;;:::i;2992:86::-;;;:::i;:::-;;;;;;;;3365:115;;;:::i;3195:92::-;;;:::i;2797:82::-;;;:::i;2605:85::-;1436:5;;:28;;-1:-1:-1;;;1436:28:4;;:5;;;;-1:-1:-1;;;;;1436:5:4;;:16;;:28;;1453:10;;1436:28;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;1436:28:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;1436:28:4;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;1436:28:4;;;;;;;;;:72;;;-1:-1:-1;1480:5:4;;:28;;-1:-1:-1;;;1480:28:4;;:5;;;;-1:-1:-1;;;;;1480:5:4;;:16;;:28;;1497:10;;1480:28;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;1480:28:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;1480:28:4;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;1480:28:4;;;;;;;;;1415:164;;;;-1:-1:-1;;;1415:164:4;;;;;;;;;;;;;;;;;2673:10:::1;:8;:10::i;:::-;2605:85::o:0;711:519:3:-;1083:5:4;;:33;;-1:-1:-1;;;1083:33:4;;:5;;;;-1:-1:-1;;;;;1083:5:4;;:21;;:33;;1105:10;;1083:33;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;1083:33:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;1083:33:4;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;1083:33:4;;;;;;;;;1062:119;;;;-1:-1:-1;;;1062:119:4;;;;;;;;;1366:8:10::1;:6;:8::i;:::-;1365:9;1357:38;;;;-1:-1:-1::0;;;1357:38:10::1;;;;;;;;;329:6:3::2;876:11;:39;;868:92;;;;-1:-1:-1::0;;;868:92:3::2;;;;;;;;;970:14;329:6;1013:11;987:10;-1:-1:-1::0;;;;;987:21:3::2;;:23;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24::::0;17:12:::2;2:2;987:23:3;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::2;77:16;74:1;67:27;5:2;987:23:3;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;987:23:3;;;;;;;;;:37;:64;;;;;;::::0;-1:-1:-1;1069:11:3;1061:64:::2;;;;-1:-1:-1::0;;;1061:64:3::2;;;;;;;;;1136:31;::::0;-1:-1:-1;;;1136:31:3;;-1:-1:-1;;;;;1136:19:3;::::2;::::0;::::2;::::0;:31:::2;::::0;1156:2;;1160:6;;1136:31:::2;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24::::0;17:12:::2;2:2;1136:31:3;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::2;77:16;74:1;67:27;5:2;1136:31:3;;;;1212:2;-1:-1:-1::0;;;;;1182:41:3::2;1199:10;-1:-1:-1::0;;;;;1182:41:3::2;;1216:6;1182:41;;;;;;;;;;;;;;;1405:1:10;711:519:3::0;;;:::o;1052:84:10:-;1099:4;1122:7;;;1052:84;:::o;278:57:3:-;329:6;278:57;:::o;3562:119:4:-;3616:7;3642;:5;:7::i;:::-;-1:-1:-1;;;;;3642:17:4;;3668:4;3642:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;3642:32:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;3642:32:4;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;3642:32:4;;;;;;;;;3635:39;;3562:119;:::o;2287:129::-;1260:5;;:28;;-1:-1:-1;;;1260:28:4;;:5;;;;-1:-1:-1;;;;;1260:5:4;;:16;;:28;;1277:10;;1260:28;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;1260:28:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;1260:28:4;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;1260:28:4;;;;;;;;;1239:108;;;;-1:-1:-1;;;1239:108:4;;;;;;;;;2359:5:::1;:19:::0;;-1:-1:-1;;;;;;2359:19:4::1;;-1:-1:-1::0;;;;;2359:19:4;::::1;::::0;;::::1;::::0;;;::::1;::::0;;2393:16:::1;::::0;2359:19;;2393:16:::1;::::0;::::1;2287:129:::0;:::o;2469:81::-;1436:5;;:28;;-1:-1:-1;;;1436:28:4;;:5;;;;-1:-1:-1;;;;;1436:5:4;;:16;;:28;;1453:10;;1436:28;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;1436:28:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;1436:28:4;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;1436:28:4;;;;;;;;;:72;;;-1:-1:-1;1480:5:4;;:28;;-1:-1:-1;;;1480:28:4;;:5;;;;-1:-1:-1;;;;;1480:5:4;;:16;;:28;;1497:10;;1480:28;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;1480:28:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;1480:28:4;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;1480:28:4;;;;;;;;;1415:164;;;;-1:-1:-1;;;1415:164:4;;;;;;;;;2535:8:::1;:6;:8::i;2992:86::-:0;3037:4;3060:5;;;;;;;;;-1:-1:-1;;;;;3060:5:4;-1:-1:-1;;;;;3060:9:4;;:11;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;3060:11:4;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;3060:11:4;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;3060:11:4;;;;;;;;3365:115;3417:7;3443:5;:3;:5::i;3195:92::-;3242:6;3267:5;;;;;;;;;-1:-1:-1;;;;;3267:5:4;-1:-1:-1;;;;;3267:11:4;;:13;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2797:82:4;2843:5;2867;;;;-1:-1:-1;;;;;2867:5:4;;2797:82::o;2064:117:10:-;1631:8;:6;:8::i;:::-;1623:41;;;;-1:-1:-1;;;1623:41:10;;;;;;;;;2132:5:::1;2122:15:::0;;-1:-1:-1;;2122:15:10::1;::::0;;2152:22:::1;2161:12;:10;:12::i;:::-;2152:22;;;;;;;;;;;;;;;2064:117::o:0;1817:115::-;1366:8;:6;:8::i;:::-;1365:9;1357:38;;;;-1:-1:-1;;;1357:38:10;;;;;;;;;1876:7:::1;:14:::0;;-1:-1:-1;;1876:14:10::1;1886:4;1876:14;::::0;;1905:20:::1;1912:12;598:104:9::0;685:10;598:104;:::o;1064:241:-1:-;;1168:2;1156:9;1147:7;1143:23;1139:32;1136:2;;;-1:-1;;1174:12;1136:2;85:6;72:20;97:33;124:5;97:33;;;1226:63;1130:175;-1:-1;;;1130:175;1312:257;;1424:2;1412:9;1403:7;1399:23;1395:32;1392:2;;;-1:-1;;1430:12;1392:2;223:6;217:13;13714:5;11715:13;11708:21;13692:5;13689:32;13679:2;;-1:-1;;13725:12;1576:291;;1705:2;1693:9;1684:7;1680:23;1676:32;1673:2;;;-1:-1;;1711:12;1673:2;375:6;369:13;387:47;428:5;387:47;;2168:529;;;;2325:2;2313:9;2304:7;2300:23;2296:32;2293:2;;;-1:-1;;2331:12;2293:2;710:6;697:20;722:52;768:5;722:52;;;2383:82;-1:-1;2502:2;2541:22;;72:20;97:33;72:20;97:33;;;2287:410;;2510:63;;-1:-1;;;2610:2;2649:22;;;;853:20;;2287:410;2704:263;;2819:2;2807:9;2798:7;2794:23;2790:32;2787:2;;;-1:-1;;2825:12;2787:2;-1:-1;1001:13;;2781:186;-1:-1;2781:186;6530:213;-1:-1;;;;;12142:54;;;;3194:37;;6648:2;6633:18;;6619:124;6986:324;-1:-1;;;;;12142:54;;;;3194:37;;7296:2;7281:18;;6481:37;7132:2;7117:18;;7103:207;7317:201;11715:13;;11708:21;3308:34;;7429:2;7414:18;;7400:118;8261:407;8452:2;8466:47;;;4054:2;8437:18;;;11483:19;-1:-1;;;11523:14;;;4070:43;4132:12;;;8423:245;8675:407;8866:2;8880:47;;;4383:2;8851:18;;;11483:19;4419:34;11523:14;;;4399:55;-1:-1;;;4474:12;;;4467:37;4523:12;;;8837:245;9089:407;9280:2;9294:47;;;4774:2;9265:18;;;11483:19;4810:34;11523:14;;;4790:55;-1:-1;;;4865:12;;;4858:31;4908:12;;;9251:245;9503:407;9694:2;9708:47;;;5159:2;9679:18;;;11483:19;-1:-1;;;11523:14;;;5175:39;5233:12;;;9665:245;9917:407;10108:2;10122:47;;;5484:2;10093:18;;;11483:19;5520:34;11523:14;;;5500:55;-1:-1;;;5575:12;;;5568:32;5619:12;;;10079:245;10331:407;10522:2;10536:47;;;5870:2;10507:18;;;11483:19;5906:34;11523:14;;;5886:55;-1:-1;;;5961:12;;;5954:25;5998:12;;;10493:245;10745:407;10936:2;10950:47;;;6249:2;10921:18;;;11483:19;6285:34;11523:14;;;6265:55;-1:-1;;;6340:12;;;6333:32;6384:12;;;10907:245;11159:213;6481:37;;;11277:2;11262:18;;11248:124;13509:117;-1:-1;;;;;12142:54;;13568:35;;13558:2;;13617:1;;13607:12;13558:2;13552:74;
Swarm Source
ipfs://4e25f0b6fe7d2d6a88b08376b639974725a9a76b10c977cd4ff14276a86f3980
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 24 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
[ 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.