0xd66cb988…27a7sent to0x00000000…ace7·#19,562,525·view on Etherscan
data:application/vnd.facet.tx+json;rule=esip6,{"op":"create","data":{"init_code_hash":"0xa2a9d5bf9901d7a15ae08ceb568dac12d14dab2d5994ec8037feae7aeeb4e2c7","args":{},"source_code":"pragma(:rubidity, \"1.0.0\")\ncontract(:ERC20, abstract: true) {\n event(:Transfer, { from: :address, to: :address, amount: :uint256 })\n event(:Approval, { owner: :address, spender: :address, amount: :uint256 })\n string(:public, :name)\n string(:public, :symbol)\n uint8(:public, :decimals)\n uint256(:public, :totalSupply)\n mapping(({ address: :uint256 }), :public, :balanceOf)\n mapping(({ address: mapping(address: :uint256) }), :public, :allowance)\n constructor(name: :string, symbol: :string, decimals: :uint8) {\n s.name=name\n s.symbol=symbol\n s.decimals=decimals\n }\n function(:approve, { spender: :address, amount: :uint256 }, :public, :virtual, returns: :bool) {\n s.allowance[msg.sender][spender] = amount\n emit(:Approval, owner: msg.sender, spender: spender, amount: amount)\n return true\n }\n function(:transfer, { to: :address, amount: :uint256 }, :public, :virtual, returns: :bool) {\n require(s.balanceOf[msg.sender] >= amount, \"Insufficient balance\")\n s.balanceOf[msg.sender] -= amount\n s.balanceOf[to] += amount\n emit(:Transfer, from: msg.sender, to: to, amount: amount)\n return true\n }\n function(:transferFrom, { from: :address, to: :address, amount: :uint256 }, :public, :virtual, returns: :bool) {\n allowed = s.allowance[from][msg.sender]\n require(s.balanceOf[from] >= amount, \"Insufficient balance\")\n require(allowed >= amount, \"Insufficient allowance\")\n s.allowance[from][msg.sender] = allowed - amount\n s.balanceOf[from] -= amount\n s.balanceOf[to] += amount\n emit(:Transfer, from: from, to: to, amount: amount)\n return true\n }\n function(:_mint, { to: :address, amount: :uint256 }, :internal, :virtual) {\n s.totalSupply += amount\n s.balanceOf[to] += amount\n emit(:Transfer, from: address(0), to: to, amount: amount)\n }\n function(:_burn, { from: :address, amount: :uint256 }, :internal, :virtual) {\n require(s.balanceOf[from] >= amount, \"Insufficient balance\")\n s.balanceOf[from] -= amount\n s.totalSupply -= amount\n emit(:Transfer, from: from, to: address(0), amount: amount)\n }\n}\ncontract(:Ownable, abstract: true) {\n address(:public, :owner)\n event(:OwnershipTransferred, { previousOwner: :address, newOwner: :address })\n constructor(owner: :address) {\n s.owner=owner\n }\n function(:transferOwnership, { newOwner: :address }, :public) {\n onlyOwner!\n previousOwner = s.owner\n s.owner=newOwner\n emit(:OwnershipTransferred, previousOwner: previousOwner, newOwner: newOwner)\n }\n function(:onlyOwner!, :internal) {\n require(msg.sender == s.owner, \"msg.sender is not the owner\")\n }\n}\ncontract(:Pausable, abstract: true) {\n bool(:public, :paused)\n event(:Paused, { account: :address })\n event(:Unpaused, { account: :address })\n constructor(initialPauseState: :bool) {\n s.paused=initialPauseState\n }\n function(:_pause, :internal) {\n s.paused=true\n emit(:Paused, account: msg.sender)\n }\n function(:_unpause, :internal) {\n s.paused=false\n emit(:Unpaused, account: msg.sender)\n }\n function(:whenPaused!, :internal) {\n require(s.paused, \"Contract is not paused\")\n }\n function(:whenNotPaused!, :internal) {\n require(!s.paused, \"Contract is paused\")\n }\n}\ncontract(:Upgradeable, abstract: true) {\n address(:public, :upgradeAdmin)\n event(:ContractUpgraded, { oldHash: :bytes32, newHash: :bytes32 })\n event(:UpgradeAdminChanged, { newUpgradeAdmin: :address })\n constructor(upgradeAdmin: :address) {\n s.upgradeAdmin=upgradeAdmin\n }\n function(:setUpgradeAdmin, { newUpgradeAdmin: :address }, :public) {\n require(msg.sender == s.upgradeAdmin, \"NOT_AUTHORIZED\")\n s.upgradeAdmin=newUpgradeAdmin\n emit(:UpgradeAdminChanged, newUpgradeAdmin: newUpgradeAdmin)\n }\n function(:upgradeAndCall, { newHash: :bytes32, newSource: :string, migrationCalldata: :string }, :public) {\n upgrade(newHash: newHash, newSource: newSource)\n (success, data) = address(this).call(migrationCalldata)\n require(success, \"Migration failed\")\n }\n function(:upgrade, { newHash: :bytes32, newSource: :string }, :public) {\n currentHash = this.currentInitCodeHash\n require(msg.sender == s.upgradeAdmin, \"NOT_AUTHORIZED\")\n this.upgradeImplementation(newHash, newSource)\n emit(:ContractUpgraded, oldHash: currentHash, newHash: newHash)\n }\n}\ncontract(:ERC20Locker, is: [:Ownable, :Upgradeable, :Pausable], upgradeable: true) {\n event(:Deposit, { token: :address, amount: :uint256, lockDate: :uint256, unlockDate: :uint256, withdrawer: :address, lockId: :uint256 })\n event(:Relock, { token: :address, lockId: :uint256, unlockDate: :uint256 })\n event(:Withdraw, { token: :address, amount: :uint256, withdrawer: :address, lockId: :uint256 })\n struct(:TokenLock) {\n uint256(:lockId)\n address(:token)\n address(:owner)\n uint256(:amount)\n uint256(:lockDate)\n uint256(:unlockDate)\n }\n uint256(:public, :nextLockId)\n mapping(({ uint256: :TokenLock }), :public, :tokenLocks)\n constructor {\n s.nextLockId=1\n self.Upgradeable.constructor(upgradeAdmin: msg.sender)\n self.Ownable.constructor(owner: msg.sender)\n }\n function(:lockToken, { token: :address, amount: :uint256, unlockDate: :uint256, withdrawer: :address }, :public) {\n whenNotPaused!\n require(unlockDate < 10000000000, \"Timestamp is in seconds\")\n require(unlockDate > block.timestamp, \"Unlock time must be in the future\")\n require(amount > 0, \"Amount must be greater than 0\")\n require(withdrawer != address(0), \"Invalid withdrawer\")\n require(ERC20(token).transferFrom(msg.sender, address(this), amount), \"Transfer failed\")\n tokenLock = TokenLock(lockId: s.nextLockId, token: token, owner: withdrawer, amount: amount, lockDate: block.timestamp, unlockDate: unlockDate)\n require(s.tokenLocks[tokenLock.lockId] == TokenLock(), \"Lock already exists\")\n s.tokenLocks[tokenLock.lockId] = tokenLock\n s.nextLockId += 1\n emit(:Deposit, token: tokenLock.token, amount: tokenLock.amount, lockDate: tokenLock.lockDate, unlockDate: tokenLock.unlockDate, withdrawer: tokenLock.owner, lockId: tokenLock.lockId)\n }\n function(:relock, { lockId: :uint256, unlockDate: :uint256 }, :public) {\n tokenLock = s.tokenLocks[lockId]\n require(tokenLock.owner == msg.sender, \"Only owner\")\n require(unlockDate < 10000000000, \"Timestamp is in seconds\")\n require(unlockDate > block.timestamp, \"Unlock time must be in the future\")\n require(unlockDate > tokenLock.unlockDate, \"Unlock date must be after current unlock date\")\n tokenLock.unlockDate=unlockDate\n emit(:Relock, token: tokenLock.token, lockId: lockId, unlockDate: unlockDate)\n }\n function(:withdraw, { lockId: :uint256, amount: :uint256 }, :public) {\n tokenLock = s.tokenLocks[lockId]\n require(tokenLock.owner == msg.sender, \"Only owner\")\n require(amount > 0, \"Amount must be greater than 0\")\n require(tokenLock != TokenLock(), \"Lock does not exist\")\n require(block.timestamp > tokenLock.unlockDate, \"Tokens are still locked\")\n require(tokenLock.amount >= amount, \"Insufficient balance\")\n tokenLock.amount -= amount\n token = tokenLock.token\n if tokenLock.amount == 0\n s.tokenLocks[lockId] = TokenLock()\n end\n require(ERC20(token).transfer(msg.sender, amount), \"Transfer failed\")\n emit(:Withdraw, token: token, amount: amount, withdrawer: msg.sender, lockId: lockId)\n }\n function(:pause, :public) {\n onlyOwner!\n _pause\n }\n function(:unpause, :public) {\n onlyOwner!\n _unpause\n }\n}\n"}}