More Info
Private Name Tags
ContractCreator
Latest 1 internal transaction
Advanced mode:
Parent Transaction Hash | Block | From | To | |||
---|---|---|---|---|---|---|
15661095 | 706 days ago | 0.01 ETH |
Loading...
Loading
Contract Name:
LockContract
Compiler Version
v0.6.12+commit.27d51765
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2022-10-02 */ /** *Submitted for verification at Etherscan.io on 2022-08-11 */ pragma experimental ABIEncoderV2; // 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; } } // File: @openzeppelin/contracts/access/Ownable.sol pragma solidity >=0.6.0 <0.8.0; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } /** * @dev Returns the address of the current owner. */ function owner() public view 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 { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } // File: @openzeppelin/contracts/math/SafeMath.sol pragma solidity >=0.6.0 <0.8.0; /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { 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) { 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) { // 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) { 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) { 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) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath: subtraction overflow"); 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) { if (a == 0) return 0; uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @dev Returns the integer division of two unsigned integers, reverting on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "SafeMath: division by zero"); 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) { require(b > 0, "SafeMath: modulo by zero"); 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) { 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. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryDiv}. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { require(b > 0, errorMessage); 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) { require(b > 0, errorMessage); return a % b; } } // File: bsc-library/contracts/IBEP20.sol pragma solidity >=0.4.0; interface IBEP20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the token decimals. */ function decimals() external view returns (uint8); /** * @dev Returns the token symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the token name. */ function name() external view returns (string memory); /** * @dev Returns the bep token owner. */ function getOwner() external view returns (address); /** * @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/utils/Address.sol pragma solidity >=0.6.2 <0.8.0; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain`call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{value: value}(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @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); } } } } // File: bsc-library/contracts/SafeBEP20.sol pragma solidity ^0.6.0; /** * @title SafeBEP20 * @dev Wrappers around BEP20 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 SafeBEP20 for IBEP20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeBEP20 { using SafeMath for uint256; using Address for address; function safeTransfer( IBEP20 token, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom( IBEP20 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 * {IBEP20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove( IBEP20 token, address spender, uint256 value ) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' // solhint-disable-next-line max-line-length require( (value == 0) || (token.allowance(address(this), spender) == 0), "SafeBEP20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance( IBEP20 token, address spender, uint256 value ) internal { uint256 newAllowance = token.allowance(address(this), spender).add(value); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance( IBEP20 token, address spender, uint256 value ) internal { uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeBEP20: decreased allowance below zero"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IBEP20 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, "SafeBEP20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeBEP20: BEP20 operation did not succeed"); } } } pragma solidity 0.6.12; contract LockContract is Ownable { using SafeMath for uint256; using SafeBEP20 for IBEP20; event LockCreated(uint256 id, address indexed user, address indexed token); event LockWithdraw(uint256 id, address indexed user, address indexed token); mapping(address => uint256[]) public userIds; mapping (uint256 => Items) public lockedToken; // track all locks address public treasury; uint256 public requiredPayment = 10000000000000000; uint256 public id = 0; bool public changeLockAbility = true; constructor(address _treasury) public { treasury = _treasury; transferOwnership(_treasury); } struct Items { address tokenAddress; // LP or token addresss address withdrawalAddress; // user address uint256 tokenAmount; // amount deposited uint256 unlockTime; // after how much time bool withdrawn; // keep tracks of withdraw locks } function getIdData(uint256 _id) public view returns(Items memory){ return lockedToken[_id]; } function changeTreasury(address _treasury) public { require(msg.sender == treasury, 'invalid address'); treasury = _treasury; } function changePayment(uint256 _amount) public { require(msg.sender == treasury, 'invalid address'); requiredPayment = _amount; } // FUNCTION to lock funds // othertoken is LP address or token // otheramount is amount of LPs // locktime is time in seconds function lockFunds(address othertoken, uint256 otherAmount, uint256 lockTime) public payable { require(msg.value >= requiredPayment, 'invalid eth amount paid'); require(otherAmount > 0, 'invalid amount'); payable(treasury).transfer(msg.value); // transfer LPs in smart contract IBEP20(othertoken).safeTransferFrom(msg.sender, address(this), otherAmount); // create locker lockedToken[id].tokenAddress = othertoken; lockedToken[id].withdrawalAddress = msg.sender; lockedToken[id].unlockTime = lockTime; lockedToken[id].withdrawn = false; userIds[msg.sender].push(id); id = id.add(1); emit LockCreated(id.sub(1), msg.sender, othertoken); } function withdrawFunds(uint256 _id) public { require(block.timestamp >= lockedToken[_id].unlockTime, 'tokens still in lock'); require(msg.sender == lockedToken[_id].withdrawalAddress, 'Not owner of the deposit'); require(!lockedToken[_id].withdrawn, 'tokens withdrawn'); IBEP20(lockedToken[_id].tokenAddress).safeTransfer(msg.sender, lockedToken[_id].tokenAmount); lockedToken[_id].withdrawn = true; emit LockWithdraw(_id, msg.sender, lockedToken[_id].tokenAddress); } function getIdsWithPagination(uint256 cursor, uint256 howMany, address _sender) public view returns(uint256[] memory values, uint256 newCursor){ uint256 length = howMany; if (length > userIds[_sender].length - cursor) { length = userIds[_sender].length - cursor; } values = new uint256[](length); for (uint256 i = 0; i < length; i++) { values[i] = userIds[_sender][cursor + i]; } return (values, cursor + length); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_treasury","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"}],"name":"LockCreated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"}],"name":"LockWithdraw","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"},{"inputs":[],"name":"changeLockAbility","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"changePayment","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_treasury","type":"address"}],"name":"changeTreasury","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"getIdData","outputs":[{"components":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"address","name":"withdrawalAddress","type":"address"},{"internalType":"uint256","name":"tokenAmount","type":"uint256"},{"internalType":"uint256","name":"unlockTime","type":"uint256"},{"internalType":"bool","name":"withdrawn","type":"bool"}],"internalType":"struct LockContract.Items","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"cursor","type":"uint256"},{"internalType":"uint256","name":"howMany","type":"uint256"},{"internalType":"address","name":"_sender","type":"address"}],"name":"getIdsWithPagination","outputs":[{"internalType":"uint256[]","name":"values","type":"uint256[]"},{"internalType":"uint256","name":"newCursor","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"id","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"othertoken","type":"address"},{"internalType":"uint256","name":"otherAmount","type":"uint256"},{"internalType":"uint256","name":"lockTime","type":"uint256"}],"name":"lockFunds","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"lockedToken","outputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"address","name":"withdrawalAddress","type":"address"},{"internalType":"uint256","name":"tokenAmount","type":"uint256"},{"internalType":"uint256","name":"unlockTime","type":"uint256"},{"internalType":"bool","name":"withdrawn","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"requiredPayment","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasury","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"userIds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"withdrawFunds","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)
000000000000000000000000e3c601b1fc6564ebf5603fcad7956697761e39db
-----Decoded View---------------
Arg [0] : _treasury (address): 0xe3C601b1FC6564ebf5603fCaD7956697761E39Db
-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000e3c601b1fc6564ebf5603fcad7956697761e39db
Deployed Bytecode Sourcemap
26386:3400:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28727:533;;;;;;;;;;-1:-1:-1;28727:533:0;;;;;:::i;:::-;;:::i;:::-;;26659:44;;;;;;;;;;-1:-1:-1;26659:44:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;26811:50;;;;;;;;;;;;;:::i;26781:23::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;2830:148::-;;;;;;;;;;;;;:::i;2179:87::-;;;;;;;;;;;;;:::i;27371:107::-;;;;;;;;;;-1:-1:-1;27371:107:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;26868:21::-;;;;;;;;;;;;;:::i;27486:150::-;;;;;;;;;;-1:-1:-1;27486:150:0;;;;;:::i;:::-;;:::i;27952:767::-;;;;;;:::i;:::-;;:::i;26710:45::-;;;;;;;;;;-1:-1:-1;26710:45:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;:::i;26898:36::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;29270:511::-;;;;;;;;;;-1:-1:-1;29270:511:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;3133:244::-;;;;;;;;;;-1:-1:-1;3133:244:0;;;;;:::i;:::-;;:::i;27644:152::-;;;;;;;;;;-1:-1:-1;27644:152:0;;;;;:::i;:::-;;:::i;28727:533::-;28808:16;;;;:11;:16;;;;;:27;;;28789:15;:46;;28781:79;;;;-1:-1:-1;;;28781:79:0;;;;;;;:::i;:::-;;;;;;;;;28893:16;;;;:11;:16;;;;;:34;;;-1:-1:-1;;;;;28893:34:0;28879:10;:48;28871:85;;;;-1:-1:-1;;;28871:85:0;;;;;;;:::i;:::-;28976:16;;;;:11;:16;;;;;:26;;;;;28975:27;28967:56;;;;-1:-1:-1;;;28967:56:0;;;;;;;:::i;:::-;29099:16;;;;:11;:16;;;;;;;;:28;;;;29043:29;;29036:92;;-1:-1:-1;;;;;29043:29:0;;;;29087:10;;29036:50;:92::i;:::-;29139:16;;;;:11;:16;;;;;;;:26;;;:33;;-1:-1:-1;;29139:33:0;29168:4;29139:33;;;29220:29;29190:60;;-1:-1:-1;;;;;29220:29:0;;;;29208:10;;29190:60;;;;29151:3;;29190:60;:::i;:::-;;;;;;;;28727:533;:::o;26659:44::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;26811:50::-;;;;:::o;26781:23::-;;;-1:-1:-1;;;;;26781:23:0;;:::o;2830:148::-;2410:12;:10;:12::i;:::-;-1:-1:-1;;;;;2399:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2399:23:0;;2391:68;;;;-1:-1:-1;;;2391:68:0;;;;;;;:::i;:::-;2937:1:::1;2921:6:::0;;2900:40:::1;::::0;-1:-1:-1;;;;;2921:6:0;;::::1;::::0;-1:-1:-1;;;;;;;;;;;2900:40:0;2937:1;;2900:40:::1;2968:1;2951:19:::0;;-1:-1:-1;;;;;;2951:19:0::1;::::0;;2830:148::o;2179:87::-;2225:7;2252:6;-1:-1:-1;;;;;2252:6:0;2179:87;:::o;27371:107::-;27423:12;;:::i;:::-;-1:-1:-1;27454:16:0;;;;:11;:16;;;;;;;;;27447:23;;;;;;;;;-1:-1:-1;;;;;27447:23:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27371:107::o;26868:21::-;;;;:::o;27486:150::-;27569:8;;-1:-1:-1;;;;;27569:8:0;27555:10;:22;27547:50;;;;-1:-1:-1;;;27547:50:0;;;;;;;:::i;:::-;27608:8;:20;;-1:-1:-1;;;;;;27608:20:0;-1:-1:-1;;;;;27608:20:0;;;;;;;;;;27486:150::o;27952:767::-;28077:15;;28064:9;:28;;28056:64;;;;-1:-1:-1;;;28056:64:0;;;;;;;:::i;:::-;28153:1;28139:11;:15;28131:42;;;;-1:-1:-1;;;28131:42:0;;;;;;;:::i;:::-;28192:8;;28184:37;;-1:-1:-1;;;;;28192:8:0;;;;28211:9;28184:37;;;;;28192:8;28184:37;28192:8;28184:37;28211:9;28192:8;28184:37;;;;;;;;;;;;;;;;;;;;-1:-1:-1;28277:75:0;-1:-1:-1;;;;;28277:35:0;;28313:10;28333:4;28340:11;28277:35;:75::i;:::-;28403:2;;;28391:15;;;;:11;:15;;;;;;;;:41;;-1:-1:-1;;;;;;28391:41:0;;;-1:-1:-1;;;;;28391:41:0;;;;;;28455:2;;28443:15;;;;;-1:-1:-1;28443:33:0;;;:46;;28479:10;28443:46;;;;;;28512:2;;28500:15;;;;;:26;;:37;;;28560:2;;28548:15;;;;;:25;;:33;;-1:-1:-1;;28548:33:0;;;28592:19;;;;;;;;;28617:2;;28592:28;;;;;;;;;;;;;;;;;;28636:2;;:9;;:6;:9::i;:::-;28631:2;:14;;;-1:-1:-1;;;;;28663:46:0;;;28686:10;;28663:46;;28675:9;;28682:1;28675:6;:9::i;:::-;28663:46;;;;;;:::i;:::-;;;;;;;;27952:767;;;:::o;26710:45::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;26710:45:0;;;;;;;;;;;;;:::o;26898:36::-;;;;;;:::o;29270:511::-;-1:-1:-1;;;;;29472:16:0;;29395:17;29472:16;;;:7;:16;;;;;:23;29370;;29395:17;29441:7;;29472:32;;;29463:41;;29459:115;;;-1:-1:-1;;;;;;29530:16:0;;;;;;:7;:16;;;;;:23;:32;;;29459:115;29609:6;-1:-1:-1;;;;;29595:21:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;29595:21:0;;29586:30;;29632:9;29627:104;29651:6;29647:1;:10;29627:104;;;-1:-1:-1;;;;;29691:16:0;;;;;;:7;:16;;;;;:28;;29708:10;;;;29691:28;;;;;;;;;;;;;;29679:6;29686:1;29679:9;;;;;;;;;;;;;;;;;:40;29659:3;;29627:104;;;-1:-1:-1;29757:15:0;;;-1:-1:-1;29270:511:0;;;;;;:::o;3133:244::-;2410:12;:10;:12::i;:::-;-1:-1:-1;;;;;2399:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2399:23:0;;2391:68;;;;-1:-1:-1;;;2391:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;3222:22:0;::::1;3214:73;;;;-1:-1:-1::0;;;3214:73:0::1;;;;;;;:::i;:::-;3324:6;::::0;;3303:38:::1;::::0;-1:-1:-1;;;;;3303:38:0;;::::1;::::0;3324:6;::::1;::::0;-1:-1:-1;;;;;;;;;;;3303:38:0;::::1;3352:6;:17:::0;;-1:-1:-1;;;;;;3352:17:0::1;-1:-1:-1::0;;;;;3352:17:0;;;::::1;::::0;;;::::1;::::0;;3133:244::o;27644:152::-;27724:8;;-1:-1:-1;;;;;27724:8:0;27710:10;:22;27702:50;;;;-1:-1:-1;;;27702:50:0;;;;;;;:::i;:::-;27763:15;:25;27644:152::o;23065:211::-;23182:86;23202:5;23232:23;;;23257:2;23261:5;23209:58;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;23209:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;23209:58:0;-1:-1:-1;;;;;;23209:58:0;;;;;;;;;;23182:19;:86::i;:::-;23065:211;;;:::o;719:106::-;807:10;719:106;:::o;23284:248::-;23428:96;23448:5;23478:27;;;23507:4;23513:2;23517:5;23455:68;;;;;;;;;;:::i;23428:96::-;23284:248;;;;:::o;6177:179::-;6235:7;6267:5;;;6291:6;;;;6283:46;;;;-1:-1:-1;;;6283:46:0;;;;;;;:::i;:::-;6347:1;-1:-1:-1;6177:179:0;;;;;:::o;6639:158::-;6697:7;6730:1;6725;:6;;6717:49;;;;-1:-1:-1;;;6717:49:0;;;;;;;:::i;:::-;-1:-1:-1;6784:5:0;;;6639:158::o;25576:774::-;26000:23;26026:69;26054:4;26026:69;;;;;;;;;;;;;;;;;26034:5;-1:-1:-1;;;;;26026:27:0;;;:69;;;;;:::i;:::-;26110:17;;26000:95;;-1:-1:-1;26110:21:0;26106:237;;26265:10;26254:30;;;;;;;;;;;;:::i;:::-;26246:85;;;;-1:-1:-1;;;26246:85:0;;;;;;;:::i;17878:229::-;18015:12;18047:52;18069:6;18077:4;18083:1;18086:12;18047:21;:52::i;:::-;18040:59;;17878:229;;;;;;:::o;18998:571::-;19168:12;19226:5;19201:21;:30;;19193:81;;;;-1:-1:-1;;;19193:81:0;;;;;;;:::i;:::-;19293:18;19304:6;19293:10;:18::i;:::-;19285:60;;;;-1:-1:-1;;;19285:60:0;;;;;;;:::i;:::-;19419:12;19433:23;19460:6;-1:-1:-1;;;;;19460:11:0;19479:5;19486:4;19460:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19418:73;;;;19509:52;19527:7;19536:10;19548:12;19509:17;:52::i;:::-;19502:59;18998:571;-1:-1:-1;;;;;;;18998:571:0:o;14938:444::-;15318:20;15366:8;;;14938:444::o;21647:777::-;21797:12;21826:7;21822:595;;;-1:-1:-1;21857:10:0;21850:17;;21822:595;21971:17;;:21;21967:439;;22234:10;22228:17;22295:15;22282:10;22278:2;22274:19;22267:44;22182:148;22377:12;22370:20;;-1:-1:-1;;;22370:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;5:130::-;72:20;;-1:-1;;;;;20825:54;;21411:35;;21401:2;;21460:1;;21450:12;414:241;;518:2;506:9;497:7;493:23;489:32;486:2;;;-1:-1;;524:12;486:2;586:53;631:7;607:22;586:53;:::i;662:366::-;;;783:2;771:9;762:7;758:23;754:32;751:2;;;-1:-1;;789:12;751:2;851:53;896:7;872:22;851:53;:::i;:::-;841:63;941:2;980:22;;;;344:20;;-1:-1;;;745:283::o;1035:491::-;;;;1173:2;1161:9;1152:7;1148:23;1144:32;1141:2;;;-1:-1;;1179:12;1141:2;1241:53;1286:7;1262:22;1241:53;:::i;:::-;1231:63;1331:2;1370:22;;344:20;;-1:-1;1439:2;1478:22;;;344:20;;1135:391;-1:-1;;;1135:391::o;1533:257::-;;1645:2;1633:9;1624:7;1620:23;1616:32;1613:2;;;-1:-1;;1651:12;1613:2;223:6;217:13;21557:5;20737:13;20730:21;21535:5;21532:32;21522:2;;-1:-1;;21568:12;1797:241;;1901:2;1889:9;1880:7;1876:23;1872:32;1869:2;;;-1:-1;;1907:12;1869:2;-1:-1;344:20;;1863:175;-1:-1;1863:175::o;2045:491::-;;;;2183:2;2171:9;2162:7;2158:23;2154:32;2151:2;;;-1:-1;;2189:12;2151:2;344:20;;;-1:-1;2341:2;2380:22;;344:20;;-1:-1;2449:2;2488:22;;72:20;-1:-1;;;;;20825:54;;21411:35;;21401:2;;-1:-1;;21450:12;21401:2;2457:63;;;;2145:391;;;;;:::o;10354:271::-;;4056:5;19648:12;4167:52;4212:6;4207:3;4200:4;4193:5;4189:16;4167:52;:::i;:::-;4231:16;;;;;10488:137;-1:-1;;10488:137::o;10632:222::-;-1:-1;;;;;20825:54;;;;2786:37;;10759:2;10744:18;;10730:124::o;10861:444::-;-1:-1;;;;;20825:54;;;2786:37;;20825:54;;;;11208:2;11193:18;;2786:37;11291:2;11276:18;;10185:37;;;;11044:2;11029:18;;11015:290::o;11312:656::-;-1:-1;;;;;20825:54;;;2786:37;;20825:54;;;;11710:2;11695:18;;2786:37;11793:2;11778:18;;10185:37;;;;11876:2;11861:18;;10185:37;20737:13;;20730:21;11953:3;11938:19;;3739:34;11545:3;11530:19;;11516:452::o;11975:333::-;-1:-1;;;;;20825:54;;;;2786:37;;12294:2;12279:18;;10185:37;12130:2;12115:18;;12101:207::o;12315:481::-;12520:2;12534:47;;;19648:12;;12505:18;;;20180:19;;;12315:481;;20229:4;;20220:14;;;;19502;;;12315:481;3394:260;3419:6;3416:1;3413:13;3394:260;;;3480:13;;10185:37;;2697:14;;;;20035;;;;3441:1;3434:9;3394:260;;;-1:-1;;;12767:18;;10185:37;;;;12587:116;12491:305;-1:-1;;12491:305::o;12803:210::-;20737:13;;20730:21;3739:34;;12924:2;12909:18;;12895:118::o;13020:310::-;;13167:2;13188:17;13181:47;4404:5;19648:12;20192:6;13167:2;13156:9;13152:18;20180:19;4498:52;4543:6;20220:14;13156:9;20220:14;13167:2;4524:5;4520:16;4498:52;:::i;:::-;21331:7;21315:14;-1:-1;;21311:28;4562:39;;;;20220:14;4562:39;;13138:192;-1:-1;;13138:192::o;13337:416::-;13537:2;13551:47;;;4838:2;13522:18;;;20180:19;4874:34;20220:14;;;4854:55;-1:-1;;;4929:12;;;4922:34;4975:12;;;13508:245::o;13760:416::-;13960:2;13974:47;;;5226:2;13945:18;;;20180:19;5262:34;20220:14;;;5242:55;-1:-1;;;5317:12;;;5310:30;5359:12;;;13931:245::o;14183:416::-;14383:2;14397:47;;;5610:2;14368:18;;;20180:19;-1:-1;;;20220:14;;;5626:50;5695:12;;;14354:245::o;14606:416::-;14806:2;14820:47;;;5946:2;14791:18;;;20180:19;-1:-1;;;20220:14;;;5962:47;6028:12;;;14777:245::o;15029:416::-;15229:2;15243:47;;;6279:2;15214:18;;;20180:19;-1:-1;;;20220:14;;;6295:37;6351:12;;;15200:245::o;15452:416::-;15652:2;15666:47;;;6602:2;15637:18;;;20180:19;6638:32;20220:14;;;6618:53;6690:12;;;15623:245::o;15875:416::-;16075:2;16089:47;;;6941:2;16060:18;;;20180:19;6977:34;20220:14;;;6957:55;-1:-1;;;7032:12;;;7025:30;7074:12;;;16046:245::o;16298:416::-;16498:2;16512:47;;;7325:2;16483:18;;;20180:19;-1:-1;;;20220:14;;;7341:38;7398:12;;;16469:245::o;16721:416::-;16921:2;16935:47;;;7649:2;16906:18;;;20180:19;-1:-1;;;20220:14;;;7665:46;7730:12;;;16892:245::o;17144:416::-;17344:2;17358:47;;;7981:2;17329:18;;;20180:19;-1:-1;;;20220:14;;;7997:39;8055:12;;;17315:245::o;17567:416::-;17767:2;17781:47;;;8306:2;17752:18;;;20180:19;-1:-1;;;20220:14;;;8322:43;8384:12;;;17738:245::o;17990:416::-;18190:2;18204:47;;;18175:18;;;20180:19;8671:34;20220:14;;;8651:55;8725:12;;;18161:245::o;18413:416::-;18613:2;18627:47;;;8976:2;18598:18;;;20180:19;9012:31;20220:14;;;8992:52;9063:12;;;18584:245::o;18836:315::-;9363:23;;-1:-1;;;;;20825:54;;;2786:37;;9547:4;9536:16;;;9530:23;20825:54;;;9607:14;;;2786:37;9708:4;9697:16;;;9691:23;9768:14;;;10185:37;9868:4;9857:16;;;9851:23;9928:14;;;10185:37;10027:4;10016:16;;;10010:23;20737:13;20730:21;10081:14;;;3739:34;;;;19009:3;18994:19;;18980:171::o;19158:222::-;10185:37;;;19285:2;19270:18;;19256:124::o;20971:268::-;21036:1;21043:101;21057:6;21054:1;21051:13;21043:101;;;21124:11;;;21118:18;21105:11;;;21098:39;21079:2;21072:10;21043:101;;;21159:6;21156:1;21153:13;21150:2;;;-1:-1;;21036:1;21206:16;;21199:27;21020:219::o
Swarm Source
ipfs://f63f77f81b4ea34378295d2989b45f1b8f9d449923e39659c886a2074ccc0250
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|---|---|---|---|---|
ETH | 100.00% | $135.92 | 0.0114 | $1.55 |
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.