More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 326 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Rescue Funds | 19420082 | 229 days ago | IN | 0 ETH | 0.00247144 | ||||
Claim | 19327878 | 242 days ago | IN | 0 ETH | 0.00546469 | ||||
Claim | 19327864 | 242 days ago | IN | 0 ETH | 0.0057244 | ||||
Claim | 19327794 | 242 days ago | IN | 0 ETH | 0.0075733 | ||||
Claim | 19327676 | 242 days ago | IN | 0 ETH | 0.00578877 | ||||
Claim | 18756534 | 322 days ago | IN | 0 ETH | 0.00151703 | ||||
Claim | 18615267 | 342 days ago | IN | 0 ETH | 0.00235394 | ||||
Claim | 18598849 | 344 days ago | IN | 0 ETH | 0.00104453 | ||||
Claim | 18372035 | 376 days ago | IN | 0 ETH | 0.00115297 | ||||
Claim | 18328804 | 382 days ago | IN | 0 ETH | 0.00061516 | ||||
Claim | 18322586 | 383 days ago | IN | 0 ETH | 0.00057586 | ||||
Claim | 18310276 | 385 days ago | IN | 0 ETH | 0.00046085 | ||||
Claim | 18285798 | 388 days ago | IN | 0 ETH | 0.00131764 | ||||
Claim | 18265312 | 391 days ago | IN | 0 ETH | 0.00072901 | ||||
Claim | 18260834 | 391 days ago | IN | 0 ETH | 0.00058707 | ||||
Claim | 18228009 | 396 days ago | IN | 0 ETH | 0.00145555 | ||||
Claim | 18215723 | 398 days ago | IN | 0 ETH | 0.0012846 | ||||
Claim | 18213670 | 398 days ago | IN | 0 ETH | 0.0019412 | ||||
Claim | 18207599 | 399 days ago | IN | 0 ETH | 0.00057854 | ||||
Claim | 18206355 | 399 days ago | IN | 0 ETH | 0.00053089 | ||||
Claim | 18154380 | 406 days ago | IN | 0 ETH | 0.0005658 | ||||
Claim | 18153555 | 406 days ago | IN | 0 ETH | 0.00055376 | ||||
Claim | 18153240 | 407 days ago | IN | 0 ETH | 0.0004601 | ||||
Claim | 18067890 | 419 days ago | IN | 0 ETH | 0.0006496 | ||||
Claim | 17946385 | 436 days ago | IN | 0 ETH | 0.0009189 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
SignatureMerkleDrop128
Compiler Version
v0.8.15+commit.e14f2714
Optimization Enabled:
Yes with 1000000 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity 0.8.15; pragma abicoder v1; import "@openzeppelin/contracts/utils/math/Math.sol"; import "@openzeppelin/contracts/utils/Address.sol"; import "@openzeppelin/contracts/access/Ownable.sol"; import "@1inch/solidity-utils/contracts/libraries/SafeERC20.sol"; import "@1inch/solidity-utils/contracts/libraries/ECDSA.sol"; import "./interfaces/ISignatureMerkleDrop128.sol"; contract SignatureMerkleDrop128 is ISignatureMerkleDrop128, Ownable { using Address for address payable; using SafeERC20 for IERC20; address public immutable override token; bytes16 public immutable override merkleRoot; uint256 public immutable override depth; // This is a packed array of booleans. mapping(uint256 => uint256) private _claimedBitMap; uint256 private constant _CLAIM_GAS_COST = 60000; receive() external payable {} // solhint-disable-line no-empty-blocks constructor(address token_, bytes16 merkleRoot_, uint256 depth_) { token = token_; merkleRoot = merkleRoot_; depth = depth_; } function claim(address receiver, uint256 amount, bytes calldata merkleProof, bytes calldata signature) external override { bytes32 signedHash = ECDSA.toEthSignedMessageHash(keccak256(abi.encodePacked(receiver))); address account = ECDSA.recover(signedHash, signature); // Verify the merkle proof. bytes16 node = bytes16(keccak256(abi.encodePacked(account, amount))); (bool valid, uint256 index) = _verifyAsm(merkleProof, merkleRoot, node); require(valid, "MD: Invalid proof"); _invalidate(index); IERC20(token).safeTransfer(receiver, amount); _cashback(); } function verify(bytes calldata proof, bytes16 root, bytes16 leaf) external view returns (bool valid, uint256 index) { return _verifyAsm(proof, root, leaf); } function verify(bytes calldata proof, bytes16 leaf) external view returns (bool valid, uint256 index) { return _verifyAsm(proof, merkleRoot, leaf); } function isClaimed(uint256 index) external view override returns (bool) { uint256 claimedWordIndex = index / 256; uint256 claimedBitIndex = index % 256; uint256 claimedWord = _claimedBitMap[claimedWordIndex]; uint256 mask = (1 << claimedBitIndex); return claimedWord & mask == mask; } function _cashback() private { uint256 balance = address(this).balance; if (balance > 0) { // solhint-disable-next-line avoid-tx-origin payable(tx.origin).sendValue(Math.min(block.basefee * _CLAIM_GAS_COST, balance)); } } function _invalidate(uint256 index) private { uint256 claimedWordIndex = index >> 8; uint256 claimedBitIndex = index & 0xff; uint256 claimedWord = _claimedBitMap[claimedWordIndex]; uint256 newClaimedWord = claimedWord | (1 << claimedBitIndex); require(claimedWord != newClaimedWord, "MD: Drop already claimed"); _claimedBitMap[claimedWordIndex] = newClaimedWord; } function _verifyAsm(bytes calldata proof, bytes16 root, bytes16 leaf) private view returns (bool valid, uint256 index) { /// @solidity memory-safe-assembly assembly { // solhint-disable-line no-inline-assembly let ptr := proof.offset let mask := 1 for { let end := add(ptr, proof.length) } lt(ptr, end) { ptr := add(ptr, 0x10) } { let node := calldataload(ptr) switch lt(leaf, node) case 1 { mstore(0x00, leaf) mstore(0x10, node) } default { mstore(0x00, node) mstore(0x10, leaf) index := or(mask, index) } leaf := keccak256(0x00, 0x20) mask := shl(1, mask) } valid := iszero(shr(128, xor(root, leaf))) } unchecked { index <<= depth - proof.length / 16; } } function rescueFunds(address token_, uint256 amount) external onlyOwner { if (token_ == address(0)) { payable(msg.sender).sendValue(amount); } else { IERC20(token_).safeTransfer(msg.sender, amount); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (utils/math/Math.sol) pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a >= b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a / b + (a % b == 0 ? 0 : 1); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @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 * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (access/Ownable.sol) pragma solidity ^0.8.0; import "../utils/Context.sol"; /** * @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() { _transferOwnership(_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 { _transferOwnership(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"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; pragma abicoder v1; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol"; import "../interfaces/IDaiLikePermit.sol"; import "../libraries/RevertReasonForwarder.sol"; library SafeERC20 { error SafeTransferFailed(); error SafeTransferFromFailed(); error ForceApproveFailed(); error SafeIncreaseAllowanceFailed(); error SafeDecreaseAllowanceFailed(); error SafePermitBadLength(); // Ensures method do not revert or return boolean `true`, admits call to non-smart-contract function safeTransferFrom(IERC20 token, address from, address to, uint256 amount) internal { bytes4 selector = token.transferFrom.selector; bool success; /// @solidity memory-safe-assembly assembly { // solhint-disable-line no-inline-assembly let data := mload(0x40) mstore(data, selector) mstore(add(data, 0x04), from) mstore(add(data, 0x24), to) mstore(add(data, 0x44), amount) let status := call(gas(), token, 0, data, 100, 0x0, 0x20) success := and(status, or(iszero(returndatasize()), and(gt(returndatasize(), 31), eq(mload(0), 1)))) } if (!success) { revert SafeTransferFromFailed(); } } // Ensures method do not revert or return boolean `true`, admits call to non-smart-contract function safeTransfer(IERC20 token, address to, uint256 value) internal { if (!_makeCall(token, token.transfer.selector, to, value)) { revert SafeTransferFailed(); } } // If `approve(from, to, amount)` fails, try to `approve(from, to, 0)` before retry function forceApprove(IERC20 token, address spender, uint256 value) internal { if (!_makeCall(token, token.approve.selector, spender, value)) { if (!_makeCall(token, token.approve.selector, spender, 0) || !_makeCall(token, token.approve.selector, spender, value)) { revert ForceApproveFailed(); } } } function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 allowance = token.allowance(address(this), spender); if (value > type(uint256).max - allowance) revert SafeIncreaseAllowanceFailed(); forceApprove(token, spender, allowance + value); } function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 allowance = token.allowance(address(this), spender); if (value > allowance) revert SafeDecreaseAllowanceFailed(); forceApprove(token, spender, allowance - value); } function safePermit(IERC20 token, bytes calldata permit) internal { bool success; if (permit.length == 32 * 7) { // solhint-disable-next-line avoid-low-level-calls success = _makeCalldataCall(token, IERC20Permit.permit.selector, permit); } else if (permit.length == 32 * 8) { // solhint-disable-next-line avoid-low-level-calls success = _makeCalldataCall(token, IDaiLikePermit.permit.selector, permit); } else { revert SafePermitBadLength(); } if (!success) { RevertReasonForwarder.reRevert(); } } function _makeCall(IERC20 token, bytes4 selector, address to, uint256 amount) private returns(bool done) { /// @solidity memory-safe-assembly assembly { // solhint-disable-line no-inline-assembly let data := mload(0x40) mstore(data, selector) mstore(add(data, 0x04), to) mstore(add(data, 0x24), amount) let success := call(gas(), token, 0, data, 68, 0x0, 0x20) done := and( success, or( iszero(returndatasize()), and(gt(returndatasize(), 31), eq(mload(0), 1)) ) ) } } function _makeCalldataCall(IERC20 token, bytes4 selector, bytes calldata args) private returns(bool done) { /// @solidity memory-safe-assembly assembly { // solhint-disable-line no-inline-assembly let len := add(4, args.length) let data := mload(0x40) mstore(data, selector) calldatacopy(add(data, 0x04), args.offset, args.length) let success := call(gas(), token, 0, data, len, 0x0, 0x20) done := and( success, or( iszero(returndatasize()), and(gt(returndatasize(), 31), eq(mload(0), 1)) ) ) } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; pragma abicoder v1; import "@openzeppelin/contracts/interfaces/IERC1271.sol"; library ECDSA { function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal view returns(address signer) { /// @solidity memory-safe-assembly assembly { // solhint-disable-line no-inline-assembly let ptr := mload(0x40) mstore(ptr, hash) mstore(add(ptr, 0x20), v) mstore(add(ptr, 0x40), r) mstore(add(ptr, 0x60), s) if staticcall(gas(), 0x1, ptr, 0x80, 0, 0x20) { signer := mload(0) } } } function recover(bytes32 hash, bytes32 r, bytes32 vs) internal view returns(address signer) { /// @solidity memory-safe-assembly assembly { // solhint-disable-line no-inline-assembly let ptr := mload(0x40) mstore(ptr, hash) mstore(add(ptr, 0x20), add(27, shr(255, vs))) mstore(add(ptr, 0x40), r) mstore(add(ptr, 0x60), shr(1, shl(1, vs))) if staticcall(gas(), 0x1, ptr, 0x80, 0, 0x20) { signer := mload(0) } } } function recover(bytes32 hash, bytes calldata signature) internal view returns(address signer) { /// @solidity memory-safe-assembly assembly { // solhint-disable-line no-inline-assembly let ptr := mload(0x40) // memory[ptr:ptr+0x80] = (hash, v, r, s) switch signature.length case 65 { // memory[ptr+0x20:ptr+0x80] = (v, r, s) mstore(add(ptr, 0x20), byte(0, calldataload(add(signature.offset, 0x40)))) calldatacopy(add(ptr, 0x40), signature.offset, 0x40) } case 64 { // memory[ptr+0x20:ptr+0x80] = (v, r, s) let vs := calldataload(add(signature.offset, 0x20)) mstore(add(ptr, 0x20), add(27, shr(255, vs))) calldatacopy(add(ptr, 0x40), signature.offset, 0x20) mstore(add(ptr, 0x60), shr(1, shl(1, vs))) } default { ptr := 0 } if ptr { if gt(mload(add(ptr, 0x60)), 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) { ptr := 0 } if ptr { // memory[ptr:ptr+0x20] = (hash) mstore(ptr, hash) if staticcall(gas(), 0x1, ptr, 0x80, 0, 0x20) { signer := mload(0) } } } } } function recoverOrIsValidSignature(address signer, bytes32 hash, bytes calldata signature) internal view returns(bool success) { if ((signature.length == 64 || signature.length == 65) && recover(hash, signature) == signer) { return true; } return isValidSignature(signer, hash, signature); } function recoverOrIsValidSignature(address signer, bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal view returns(bool success) { if (recover(hash, v, r, s) == signer) { return true; } return isValidSignature(signer, hash, v, r, s); } function recoverOrIsValidSignature(address signer, bytes32 hash, bytes32 r, bytes32 vs) internal view returns(bool success) { if (recover(hash, r, vs) == signer) { return true; } return isValidSignature(signer, hash, r, vs); } function recoverOrIsValidSignature65(address signer, bytes32 hash, bytes32 r, bytes32 vs) internal view returns(bool success) { if (recover(hash, r, vs) == signer) { return true; } return isValidSignature65(signer, hash, r, vs); } function isValidSignature(address signer, bytes32 hash, bytes calldata signature) internal view returns(bool success) { // (bool success, bytes memory data) = signer.staticcall(abi.encodeWithSelector(IERC1271.isValidSignature.selector, hash, signature)); // return success && data.length >= 4 && abi.decode(data, (bytes4)) == IERC1271.isValidSignature.selector; bytes4 selector = IERC1271.isValidSignature.selector; /// @solidity memory-safe-assembly assembly { // solhint-disable-line no-inline-assembly let ptr := mload(0x40) let len := add(0x64, signature.length) mstore(ptr, selector) mstore(add(ptr, 0x04), hash) mstore(add(ptr, 0x24), 0x40) mstore(add(ptr, 0x44), signature.length) calldatacopy(add(ptr, 0x64), signature.offset, signature.length) mstore(0, 0) if staticcall(gas(), signer, ptr, len, 0, 0x20) { success := eq(selector, mload(0)) } } } function isValidSignature(address signer, bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal view returns(bool success) { bytes4 selector = IERC1271.isValidSignature.selector; /// @solidity memory-safe-assembly assembly { // solhint-disable-line no-inline-assembly let ptr := mload(0x40) let len := add(0x64, 65) mstore(ptr, selector) mstore(add(ptr, 0x04), hash) mstore(add(ptr, 0x24), 0x40) mstore(add(ptr, 0x44), 65) mstore(add(ptr, 0x64), r) mstore(add(ptr, 0x84), s) mstore8(add(ptr, 0xa4), v) mstore(0, 0) if staticcall(gas(), signer, ptr, len, 0, 0x20) { success := eq(selector, mload(0)) } } } function isValidSignature(address signer, bytes32 hash, bytes32 r, bytes32 vs) internal view returns(bool success) { // (bool success, bytes memory data) = signer.staticcall(abi.encodeWithSelector(IERC1271.isValidSignature.selector, hash, abi.encodePacked(r, vs))); // return success && data.length >= 4 && abi.decode(data, (bytes4)) == IERC1271.isValidSignature.selector; bytes4 selector = IERC1271.isValidSignature.selector; /// @solidity memory-safe-assembly assembly { // solhint-disable-line no-inline-assembly let ptr := mload(0x40) let len := add(0x64, 64) mstore(ptr, selector) mstore(add(ptr, 0x04), hash) mstore(add(ptr, 0x24), 0x40) mstore(add(ptr, 0x44), 64) mstore(add(ptr, 0x64), r) mstore(add(ptr, 0x84), vs) mstore(0, 0) if staticcall(gas(), signer, ptr, len, 0, 0x20) { success := eq(selector, mload(0)) } } } function isValidSignature65(address signer, bytes32 hash, bytes32 r, bytes32 vs) internal view returns(bool success) { // (bool success, bytes memory data) = signer.staticcall(abi.encodeWithSelector(IERC1271.isValidSignature.selector, hash, abi.encodePacked(r, vs & ~uint256(1 << 255), uint8(vs >> 255)))); // return success && data.length >= 4 && abi.decode(data, (bytes4)) == IERC1271.isValidSignature.selector; bytes4 selector = IERC1271.isValidSignature.selector; /// @solidity memory-safe-assembly assembly { // solhint-disable-line no-inline-assembly let ptr := mload(0x40) let len := add(0x64, 65) mstore(ptr, selector) mstore(add(ptr, 0x04), hash) mstore(add(ptr, 0x24), 0x40) mstore(add(ptr, 0x44), 65) mstore(add(ptr, 0x64), r) mstore(add(ptr, 0x84), shr(1, shl(1, vs))) mstore8(add(ptr, 0xa4), add(27, shr(255, vs))) mstore(0, 0) if staticcall(gas(), signer, ptr, len, 0, 0x20) { success := eq(selector, mload(0)) } } } function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 res) { // 32 is the length in bytes of hash, enforced by the type signature above // return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)); /// @solidity memory-safe-assembly assembly { // solhint-disable-line no-inline-assembly mstore(0, 0x19457468657265756d205369676e6564204d6573736167653a0a333200000000) // "\x19Ethereum Signed Message:\n32" mstore(28, hash) res := keccak256(0, 60) } } function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 res) { // return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash)); /// @solidity memory-safe-assembly assembly { // solhint-disable-line no-inline-assembly let ptr := mload(0x40) mstore(ptr, 0x1901000000000000000000000000000000000000000000000000000000000000) // "\x19\x01" mstore(add(ptr, 0x02), domainSeparator) mstore(add(ptr, 0x22), structHash) res := keccak256(ptr, 66) } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; pragma abicoder v1; // Allows anyone to claim a token if they exist in a merkle root. interface ISignatureMerkleDrop128 { // Returns the address of the token distributed by this contract. function token() external view returns (address); // Returns the merkle root of the merkle tree containing account balances available to claim. function merkleRoot() external view returns (bytes16); // Returns the tree depth of the merkle tree containing account balances available to claim. function depth() external view returns (uint256); // Claim the given amount of the token to the given address. Reverts if the inputs are invalid. function claim(address receiver, uint256 amount, bytes calldata merkleProof, bytes calldata signature) external; // Verifies that given leaf and merkle proof matches given merkle root and returns leaf index. function verify(bytes calldata proof, bytes16 root, bytes16 leaf) external view returns (bool valid, uint256 index); // Returns true if the index has been marked claimed. function isClaimed(uint256 index) external view returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @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 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 `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, 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 `from` to `to` 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 from, address to, uint256 amount ) external returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. */ interface IERC20Permit { /** * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens, * given ``owner``'s signed approval. * * IMPORTANT: The same issues {IERC20-approve} has related to transaction * ordering also apply here. * * Emits an {Approval} event. * * Requirements: * * - `spender` cannot be the zero address. * - `deadline` must be a timestamp in the future. * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` * over the EIP712-formatted function arguments. * - the signature must use ``owner``'s current nonce (see {nonces}). * * For more information on the signature format, see the * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP * section]. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; /** * @dev Returns the current nonce for `owner`. This value must be * included whenever a signature is generated for {permit}. * * Every successful call to {permit} increases ``owner``'s nonce by one. This * prevents a signature from being used multiple times. */ function nonces(address owner) external view returns (uint256); /** * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view returns (bytes32); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; pragma abicoder v1; interface IDaiLikePermit { function permit(address holder, address spender, uint256 nonce, uint256 expiry, bool allowed, uint8 v, bytes32 r, bytes32 s) external; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; pragma abicoder v1; library RevertReasonForwarder { function reRevert() internal pure { // bubble up revert reason from latest external call /// @solidity memory-safe-assembly assembly { // solhint-disable-line no-inline-assembly let ptr := mload(0x40) returndatacopy(ptr, 0, returndatasize()) revert(ptr, returndatasize()) } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (interfaces/IERC1271.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC1271 standard signature validation method for * contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271]. * * _Available since v4.1._ */ interface IERC1271 { /** * @dev Should return whether the signature provided is valid for the provided data * @param hash Hash of the data to be signed * @param signature Signature byte array associated with _data */ function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue); }
{ "optimizer": { "enabled": true, "runs": 1000000 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "metadata": { "useLiteralContent": true }, "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"token_","type":"address"},{"internalType":"bytes16","name":"merkleRoot_","type":"bytes16"},{"internalType":"uint256","name":"depth_","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"SafeTransferFailed","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"merkleProof","type":"bytes"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"depth","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"isClaimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRoot","outputs":[{"internalType":"bytes16","name":"","type":"bytes16"}],"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":[{"internalType":"address","name":"token_","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"rescueFunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"proof","type":"bytes"},{"internalType":"bytes16","name":"root","type":"bytes16"},{"internalType":"bytes16","name":"leaf","type":"bytes16"}],"name":"verify","outputs":[{"internalType":"bool","name":"valid","type":"bool"},{"internalType":"uint256","name":"index","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"proof","type":"bytes"},{"internalType":"bytes16","name":"leaf","type":"bytes16"}],"name":"verify","outputs":[{"internalType":"bool","name":"valid","type":"bool"},{"internalType":"uint256","name":"index","type":"uint256"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]
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)
000000000000000000000000111111111117dc0aa78b770fa6a738034120c3022e86beb86eb71737492d1a6c4c147e83000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009
-----Decoded View---------------
Arg [0] : token_ (address): 0x111111111117dC0aa78b770fA6A738034120C302
Arg [1] : merkleRoot_ (bytes16): 0x2e86beb86eb71737492d1a6c4c147e83
Arg [2] : depth_ (uint256): 9
-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000111111111117dc0aa78b770fa6a738034120c302
Arg [1] : 2e86beb86eb71737492d1a6c4c147e8300000000000000000000000000000000
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000009
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.