More Info
Private Name Tags
ContractCreator
Loading...
Loading
Contract Name:
OTCSale
Compiler Version
v0.8.17+commit.8df45f5f
Contract Source Code (Solidity Multiple files format)
// SPDX-License-Identifier: MIT pragma solidity 0.8.17; import "./ERC20.sol"; contract OTCSale { address public constant FIRN_MULTISIG = 0xa14664a2E58e804669E9fF1DFbC1bD981E13B0dC; ERC20 public immutable firnToken = ERC20(0xDDEA19FCE1E52497206bf1969D2d56FeD85aFF5c); address public BUYER; uint256 public immutable VESTING_DATE; uint256 public constant ETHER_AMOUNT = 10 ether; // 10 ETH uint256 public constant FIRN_AMOUNT = 1900 ether; // 1900 units, decimal of FIRN is 18, same as ether bool public dealStatus = false; constructor() { VESTING_DATE = block.timestamp + 365 days; BUYER = FIRN_MULTISIG; // initialize to ourselves. this is for edge case where someone sends funds before deal } receive() external payable { // receive ether, i.e. as a payout from Firn fees. } function sweepFunds() external { // callable by anyone; sweeps balance to buyer (bool success, ) = payable(BUYER).call{value: address(this).balance}(""); // will throw on failure require(success, "Transfer failed."); } function executeDeal() external payable { BUYER = msg.sender; require(!dealStatus, "Deal already done."); // this can easily be avoided, just as an additional safety measure require(msg.value == ETHER_AMOUNT, "Wrong amount of ether supplied."); require(firnToken.balanceOf(address(this)) == FIRN_AMOUNT, "Token balance is wrong."); // can also be checked explicitly, just to be safe dealStatus = true; // prevents Firn from exiting on line 43 (bool success, ) = payable(FIRN_MULTISIG).call{value: msg.value}(""); // will throw on failure require(success, "Transfer failed."); } function earlyExit() external { // Firn calls this to reclaim token if there is no deal. require(!dealStatus, "Deal already done."); firnToken.transfer(FIRN_MULTISIG, firnToken.balanceOf(address(this))); } function vest() external { // buyer calls this after a year to claim their token. require(block.timestamp >= VESTING_DATE, "Hasn't vested yet."); firnToken.transfer(BUYER, firnToken.balanceOf(address(this))); } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.17; // ---------------------------------------------------------------------------- // BokkyPooBah's Red-Black Tree Library v1.0-pre-release-a // // A Solidity Red-Black Tree binary search library to store and access a sorted // list of unsigned integer data. The Red-Black algorithm rebalances the binary // search tree, resulting in O(log n) insert, remove and search time (and ~gas) // // https://github.com/bokkypoobah/BokkyPooBahsRedBlackTreeLibrary // // // Enjoy. (c) BokkyPooBah / Bok Consulting Pty Ltd 2020. The MIT Licence. // ---------------------------------------------------------------------------- abstract contract BalanceTree { struct Node { address parent; address left; address right; bool red; } address public root; address constant EMPTY = address(0); mapping(address => Node) public nodes; function exists(address key) internal view returns (bool) { return (key != EMPTY) && ((key == root) || (nodes[key].parent != EMPTY)); } function sortKey(address key) internal virtual view returns (uint256); function rotateLeft(address key) internal { address cursor = nodes[key].right; address keyParent = nodes[key].parent; address cursorLeft = nodes[cursor].left; nodes[key].right = cursorLeft; if (cursorLeft != EMPTY) { nodes[cursorLeft].parent = key; } nodes[cursor].parent = keyParent; if (keyParent == EMPTY) { root = cursor; } else if (key == nodes[keyParent].left) { nodes[keyParent].left = cursor; } else { nodes[keyParent].right = cursor; } nodes[cursor].left = key; nodes[key].parent = cursor; } function rotateRight(address key) internal { address cursor = nodes[key].left; address keyParent = nodes[key].parent; address cursorRight = nodes[cursor].right; nodes[key].left = cursorRight; if (cursorRight != EMPTY) { nodes[cursorRight].parent = key; } nodes[cursor].parent = keyParent; if (keyParent == EMPTY) { root = cursor; } else if (key == nodes[keyParent].right) { nodes[keyParent].right = cursor; } else { nodes[keyParent].left = cursor; } nodes[cursor].right = key; nodes[key].parent = cursor; } function insertFixup(address key) internal { address cursor; while (key != root && nodes[nodes[key].parent].red) { address keyParent = nodes[key].parent; if (keyParent == nodes[nodes[keyParent].parent].left) { cursor = nodes[nodes[keyParent].parent].right; if (nodes[cursor].red) { nodes[keyParent].red = false; nodes[cursor].red = false; nodes[nodes[keyParent].parent].red = true; key = nodes[keyParent].parent; } else { if (key == nodes[keyParent].right) { key = keyParent; rotateLeft(key); } keyParent = nodes[key].parent; nodes[keyParent].red = false; nodes[nodes[keyParent].parent].red = true; rotateRight(nodes[keyParent].parent); } } else { cursor = nodes[nodes[keyParent].parent].left; if (nodes[cursor].red) { nodes[keyParent].red = false; nodes[cursor].red = false; nodes[nodes[keyParent].parent].red = true; key = nodes[keyParent].parent; } else { if (key == nodes[keyParent].left) { key = keyParent; rotateRight(key); } keyParent = nodes[key].parent; nodes[keyParent].red = false; nodes[nodes[keyParent].parent].red = true; rotateLeft(nodes[keyParent].parent); } } } if (nodes[root].red) nodes[root].red = false; } function insert(address key) internal { address cursor = EMPTY; address probe = root; while (probe != EMPTY) { cursor = probe; if (sortKey(key) < sortKey(probe)) { probe = nodes[probe].left; } else { probe = nodes[probe].right; } } nodes[key] = Node({parent : cursor, left : EMPTY, right : EMPTY, red : true}); if (cursor == EMPTY) { root = key; } else if (sortKey(key) < sortKey(cursor)) { nodes[cursor].left = key; } else { nodes[cursor].right = key; } insertFixup(key); } function replaceParent(address a, address b) internal { address bParent = nodes[b].parent; nodes[a].parent = bParent; if (bParent == EMPTY) { root = a; } else { if (b == nodes[bParent].left) { nodes[bParent].left = a; } else { nodes[bParent].right = a; } } } function removeFixup(address key) internal { address cursor; while (key != root && !nodes[key].red) { address keyParent = nodes[key].parent; if (key == nodes[keyParent].left) { cursor = nodes[keyParent].right; if (nodes[cursor].red) { nodes[cursor].red = false; nodes[keyParent].red = true; rotateLeft(keyParent); cursor = nodes[keyParent].right; } if (!nodes[nodes[cursor].left].red && !nodes[nodes[cursor].right].red) { nodes[cursor].red = true; key = keyParent; } else { if (!nodes[nodes[cursor].right].red) { nodes[nodes[cursor].left].red = false; nodes[cursor].red = true; rotateRight(cursor); cursor = nodes[keyParent].right; } nodes[cursor].red = nodes[keyParent].red; nodes[keyParent].red = false; nodes[nodes[cursor].right].red = false; rotateLeft(keyParent); return; // key = root; } } else { cursor = nodes[keyParent].left; if (nodes[cursor].red) { nodes[cursor].red = false; nodes[keyParent].red = true; rotateRight(keyParent); cursor = nodes[keyParent].left; } if (!nodes[nodes[cursor].right].red && !nodes[nodes[cursor].left].red) { nodes[cursor].red = true; key = keyParent; } else { if (!nodes[nodes[cursor].left].red) { nodes[nodes[cursor].right].red = false; nodes[cursor].red = true; rotateLeft(cursor); cursor = nodes[keyParent].left; } nodes[cursor].red = nodes[keyParent].red; nodes[keyParent].red = false; nodes[nodes[cursor].left].red = false; rotateRight(keyParent); return; // key = root; } } } if (nodes[key].red) nodes[key].red = false; } function remove(address key) internal { address probe; address cursor; if (nodes[key].left == EMPTY || nodes[key].right == EMPTY) { cursor = key; } else { cursor = nodes[key].right; while (nodes[cursor].left != EMPTY) { cursor = nodes[cursor].left; } } if (nodes[cursor].left != EMPTY) { probe = nodes[cursor].left; } else { probe = nodes[cursor].right; } address yParent = nodes[cursor].parent; nodes[probe].parent = yParent; if (yParent != EMPTY) { if (cursor == nodes[yParent].left) { nodes[yParent].left = probe; } else { nodes[yParent].right = probe; } } else { root = probe; } bool doFixup = !nodes[cursor].red; if (cursor != key) { replaceParent(cursor, key); nodes[cursor].left = nodes[key].left; nodes[nodes[cursor].left].parent = cursor; nodes[cursor].right = nodes[key].right; nodes[nodes[cursor].right].parent = cursor; nodes[cursor].red = nodes[key].red; (cursor, key) = (key, cursor); } if (doFixup) { removeFixup(probe); } delete nodes[cursor]; } } // ---------------------------------------------------------------------------- // End - BokkyPooBah's Red-Black Tree Library // ----------------------------------------------------------------------------
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/ERC20.sol) pragma solidity 0.8.17; import "./BalanceTree.sol"; /** * @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 BalanceTree { mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; address _owner; mapping(address => bool) public admins; modifier onlyOwner() { require(msg.sender == _owner, "Caller is not the owner."); _; } modifier onlyAdmin() { require(admins[msg.sender], "Caller is not an admin."); _; } function sortKey(address key) internal view override returns (uint256) { return _balances[key]; } /** * @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); /** * @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_; _owner = msg.sender; } function administrate(address owner_) external onlyOwner { _owner = owner_; } function setAdmin(address account, bool value) external onlyOwner { admins[account] = value; } function mint(address account, uint256 amount) external onlyAdmin { _mint(account, amount); } function burn(address account, uint256 amount) external onlyAdmin { _burn(account, amount); } /** * @dev Returns the name of the token. */ function name() public view returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view 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 pure returns (uint8) { return 18; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `to` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address to, uint256 amount) public returns (bool) { address owner = msg.sender; _transfer(owner, to, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on * `transferFrom`. This is semantically equivalent to an infinite approval. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public returns (bool) { address owner = msg.sender; _approve(owner, 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}. * * NOTE: Does not update the allowance if the current allowance * is the maximum `uint256`. * * Requirements: * * - `from` and `to` cannot be the zero address. * - `from` must have a balance of at least `amount`. * - the caller must have allowance for ``from``'s tokens of at least * `amount`. */ function transferFrom( address from, address to, uint256 amount ) public returns (bool) { address spender = msg.sender; _spendAllowance(from, spender, amount); _transfer(from, to, 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 returns (bool) { address owner = msg.sender; _approve(owner, spender, allowance(owner, 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 returns (bool) { address owner = msg.sender; uint256 currentAllowance = allowance(owner, spender); require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); unchecked { _approve(owner, spender, currentAllowance - subtractedValue); } return true; } /** * @dev Moves `amount` of tokens from `from` to `to`. * * 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: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `from` must have a balance of at least `amount`. */ function _transfer( address from, address to, uint256 amount ) internal { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(from, to, amount); uint256 fromBalance = _balances[from]; require(fromBalance >= amount, "ERC20: transfer amount exceeds balance"); unchecked { _balances[from] = fromBalance - amount; } _balances[to] += amount; if (exists(from)) remove(from); // could be false, if balance was originally 0 and you transfer 0 if (_balances[from] > 0) insert(from); // could be false, if from got emptied if (exists(to)) remove(to); // could be false, if to is new if (_balances[to] > 0) insert(to); // could be false, if 0 got transferred and was already 0. emit Transfer(from, to, amount); _afterTokenTransfer(from, to, 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 { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply += amount; _balances[account] += amount; if (exists(account)) remove(account); if (_balances[account] > 0) insert(account); 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 { 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; if (exists(account)) remove(account); // could be false, if was 0 before burn and you burn 0 if (_balances[account] > 0) insert(account); 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 { 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 Updates `owner` s allowance for `spender` based on spent `amount`. * * Does not update the allowance amount in case of infinite allowance. * Revert if not enough allowance is available. * * Might emit an {Approval} event. */ function _spendAllowance( address owner, address spender, uint256 amount ) internal { uint256 currentAllowance = allowance(owner, spender); if (currentAllowance != type(uint256).max) { require(currentAllowance >= amount, "ERC20: insufficient allowance"); unchecked { _approve(owner, spender, currentAllowance - 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 {} /** * @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 {} } // ---------------------------------------------------------------------------- // End - BokkyPooBah's Red-Black Tree Library // ----------------------------------------------------------------------------
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"BUYER","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ETHER_AMOUNT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FIRN_AMOUNT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FIRN_MULTISIG","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VESTING_DATE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"dealStatus","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"earlyExit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"executeDeal","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"firnToken","outputs":[{"internalType":"contract ERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sweepFunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"vest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]
Contract Creation Code
60c060405273ddea19fce1e52497206bf1969d2d56fed85aff5c6080526000805460ff60a01b1916905534801561003557600080fd5b50610044426301e13380610072565b60a052600080546001600160a01b03191673a14664a2e58e804669e9ff1dfbc1bd981e13b0dc179055610099565b8082018082111561009357634e487b7160e01b600052601160045260246000fd5b92915050565b60805160a0516109656100d9600039600081816101ad015261028701526000818160de0152818161035a015281816105c2015261086401526109656000f3fe6080604052600436106100c05760003560e01c80639a40633811610074578063a8fa29871161004e578063a8fa2987146101f9578063b85477c514610226578063e63db56b1461026857600080fd5b80639a4063381461019b578063a4dee155146101cf578063a8d6fe04146101e457600080fd5b8063458efde3116100a5578063458efde314610154578063498737831461016b5780637bd23fd61461017357600080fd5b806307bfe86a146100cc5780633dd7609a1461012a57600080fd5b366100c757005b600080fd5b3480156100d857600080fd5b506101007f000000000000000000000000000000000000000000000000000000000000000081565b60405173ffffffffffffffffffffffffffffffffffffffff90911681526020015b60405180910390f35b34801561013657600080fd5b50610146678ac7230489e8000081565b604051908152602001610121565b34801561016057600080fd5b50610169610285565b005b610169610469565b34801561017f57600080fd5b5061010073a14664a2e58e804669e9ff1dfbc1bd981e13b0dc81565b3480156101a757600080fd5b506101467f000000000000000000000000000000000000000000000000000000000000000081565b3480156101db57600080fd5b506101696107b1565b3480156101f057600080fd5b506101696108c6565b34801561020557600080fd5b506000546101009073ffffffffffffffffffffffffffffffffffffffff1681565b34801561023257600080fd5b506000546102589074010000000000000000000000000000000000000000900460ff1681565b6040519015158152602001610121565b34801561027457600080fd5b506101466866ffcbfd5e5a30000081565b7f0000000000000000000000000000000000000000000000000000000000000000421015610314576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601260248201527f4861736e277420766573746564207965742e000000000000000000000000000060448201526064015b60405180910390fd5b6000546040517f70a0823100000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff7f000000000000000000000000000000000000000000000000000000000000000081169263a9059cbb9291169083906370a08231906024015b602060405180830381865afa1580156103ae573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906103d291906108ed565b6040517fffffffff0000000000000000000000000000000000000000000000000000000060e085901b16815273ffffffffffffffffffffffffffffffffffffffff909216600483015260248201526044016020604051808303816000875af1158015610442573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906104669190610906565b50565b600080547fffffffffffffffffffffffff00000000000000000000000000000000000000001633179081905560ff740100000000000000000000000000000000000000009091041615610518576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601260248201527f4465616c20616c726561647920646f6e652e0000000000000000000000000000604482015260640161030b565b678ac7230489e800003414610589576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601f60248201527f57726f6e6720616d6f756e74206f6620657468657220737570706c6965642e00604482015260640161030b565b6040517f70a082310000000000000000000000000000000000000000000000000000000081523060048201526866ffcbfd5e5a300000907f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff16906370a0823190602401602060405180830381865afa15801561061e573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061064291906108ed565b146106a9576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601760248201527f546f6b656e2062616c616e63652069732077726f6e672e000000000000000000604482015260640161030b565b600080547fffffffffffffffffffffff00ffffffffffffffffffffffffffffffffffffffff167401000000000000000000000000000000000000000017815560405173a14664a2e58e804669e9ff1dfbc1bd981e13b0dc9034905b60006040518083038185875af1925050503d8060008114610741576040519150601f19603f3d011682016040523d82523d6000602084013e610746565b606091505b5050905080610466576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601060248201527f5472616e73666572206661696c65642e00000000000000000000000000000000604482015260640161030b565b60005474010000000000000000000000000000000000000000900460ff1615610836576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601260248201527f4465616c20616c726561647920646f6e652e0000000000000000000000000000604482015260640161030b565b6040517f70a082310000000000000000000000000000000000000000000000000000000081523060048201527f000000000000000000000000000000000000000000000000000000000000000073ffffffffffffffffffffffffffffffffffffffff169063a9059cbb9073a14664a2e58e804669e9ff1dfbc1bd981e13b0dc9083906370a0823190602401610391565b6000805460405173ffffffffffffffffffffffffffffffffffffffff909116904790610704565b6000602082840312156108ff57600080fd5b5051919050565b60006020828403121561091857600080fd5b8151801515811461092857600080fd5b939250505056fea2646970667358221220a47d61983c1cc5628fe7aa68483996a797945832c08a70cdfded198f725a595364736f6c63430008110033
Deployed Bytecode
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
Deployed Bytecode Sourcemap
81:2117:2:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;192:84;;;;;;;;;;;;;;;;;;204:42:3;192:55;;;174:74;;162:2;147:18;192:84:2;;;;;;;;352:47;;;;;;;;;;;;391:8;352:47;;;;;405:25:3;;;393:2;378:18;352:47:2;259:177:3;1966:230:2;;;;;;;;;;;;;:::i;:::-;;1091:638;;;:::i;104:82::-;;;;;;;;;;;;144:42;104:82;;309:37;;;;;;;;;;;;;;;1735:225;;;;;;;;;;;;;:::i;847:238::-;;;;;;;;;;;;;:::i;282:20::-;;;;;;;;;;-1:-1:-1;282:20:2;;;;;;;;521:30;;;;;;;;;;-1:-1:-1;521:30:2;;;;;;;;;;;;;;837:14:3;;830:22;812:41;;800:2;785:18;521:30:2;672:187:3;415:48:2;;;;;;;;;;;;453:10;415:48;;1966:230;2083:12;2064:15;:31;;2056:62;;;;;;;1066:2:3;2056:62:2;;;1048:21:3;1105:2;1085:18;;;1078:30;1144:20;1124:18;;;1117:48;1182:18;;2056:62:2;;;;;;;;;2147:5;;2154:34;;;;;2182:4;2154:34;;;174:74:3;2128:18:2;:9;:18;;;;;2147:5;;;2128:18;;2154:19;;147:18:3;;2154:34:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2128:61;;;;;;;;;;1604:42:3;1592:55;;;2128:61:2;;;1574:74:3;1664:18;;;1657:34;1547:18;;2128:61:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;1966:230::o;1091:638::-;1141:5;:18;;;;1149:10;1141:18;;;;;1178:10;;;;;;1177:11;1169:42;;;;;;;2186:2:3;1169:42:2;;;2168:21:3;2225:2;2205:18;;;2198:30;2264:20;2244:18;;;2237:48;2302:18;;1169:42:2;1984:342:3;1169:42:2;391:8;1297:9;:25;1289:69;;;;;;;2533:2:3;1289:69:2;;;2515:21:3;2572:2;2552:18;;;2545:30;2611:33;2591:18;;;2584:61;2662:18;;1289:69:2;2331:355:3;1289:69:2;1376:34;;;;;1404:4;1376:34;;;174:74:3;453:10:2;;1376:9;:19;;;;;147:18:3;;1376:34:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:49;1368:85;;;;;;;2893:2:3;1368:85:2;;;2875:21:3;2932:2;2912:18;;;2905:30;2971:25;2951:18;;;2944:53;3014:18;;1368:85:2;2691:347:3;1368:85:2;1514:10;:17;;;;;;;;1602:49;;144:42;;1637:9;;1602:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1583:68;;;1694:7;1686:36;;;;;;;3455:2:3;1686:36:2;;;3437:21:3;3494:2;3474:18;;;3467:30;3533:18;3513;;;3506:46;3569:18;;1686:36:2;3253:340:3;1735:225:2;1841:10;;;;;;;1840:11;1832:42;;;;;;;2186:2:3;1832:42:2;;;2168:21:3;2225:2;2205:18;;;2198:30;2264:20;2244:18;;;2237:48;2302:18;;1832:42:2;1984:342:3;1832:42:2;1918:34;;;;;1946:4;1918:34;;;174:74:3;1884:9:2;:18;;;;;144:42;;1884:18;;1918:19;;147:18:3;;1918:34:2;14:240:3;847:238:2;936:12;962:5;;954:53;;962:5;;;;;981:21;;954:53;3043:205:3;1211:184;1281:6;1334:2;1322:9;1313:7;1309:23;1305:32;1302:52;;;1350:1;1347;1340:12;1302:52;-1:-1:-1;1373:16:3;;1211:184;-1:-1:-1;1211:184:3:o;1702:277::-;1769:6;1822:2;1810:9;1801:7;1797:23;1793:32;1790:52;;;1838:1;1835;1828:12;1790:52;1870:9;1864:16;1923:5;1916:13;1909:21;1902:5;1899:32;1889:60;;1945:1;1942;1935:12;1889:60;1968:5;1702:277;-1:-1:-1;;;1702:277:3:o
Swarm Source
ipfs://a47d61983c1cc5628fe7aa68483996a797945832c08a70cdfded198f725a5953
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|---|---|---|---|---|
ETH | 100.00% | $3,305.77 | 0.2409 | $796.44 |
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.