More Info
Private Name Tags
ContractCreator
Latest 5 from a total of 5 transactions
Latest 1 internal transaction
Parent Transaction Hash | Block | From | To | |||
---|---|---|---|---|---|---|
9696220 | 572 days ago | 0 ETH |
Loading...
Loading
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.
Contract Name:
TokenApprove
Compiler Version
v0.8.17+commit.8df45f5f
ZkSolc Version
v1.3.1
Contract Source Code (Solidity)
/** *Submitted for verification at era.zksync.network on 2024-01-04 */ // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) // OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol) // OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol) /** * @dev Collection of functions related to the address type */ library AddressUpgradeable { /** * @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 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 /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } /** * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect. * * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in * case an upgrade adds a module that needs to be initialized. * * For example: * * [.hljs-theme-light.nopadding] * ``` * contract MyToken is ERC20Upgradeable { * function initialize() initializer public { * __ERC20_init("MyToken", "MTK"); * } * } * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable { * function initializeV2() reinitializer(2) public { * __ERC20Permit_init("MyToken"); * } * } * ``` * * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}. * * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity. * * [CAUTION] * ==== * Avoid leaving a contract uninitialized. * * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed: * * [.hljs-theme-light.nopadding] * ``` * /// @custom:oz-upgrades-unsafe-allow constructor * constructor() { * _disableInitializers(); * } * ``` * ==== */ abstract contract Initializable { /** * @dev Indicates that the contract has been initialized. * @custom:oz-retyped-from bool */ uint8 private _initialized; /** * @dev Indicates that the contract is in the process of being initialized. */ bool private _initializing; /** * @dev Triggered when the contract has been initialized or reinitialized. */ event Initialized(uint8 version); /** * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope, * `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`. */ modifier initializer() { bool isTopLevelCall = !_initializing; require( (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1), "Initializable: contract is already initialized" ); _initialized = 1; if (isTopLevelCall) { _initializing = true; } _; if (isTopLevelCall) { _initializing = false; emit Initialized(1); } } /** * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be * used to initialize parent contracts. * * `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original * initialization step. This is essential to configure modules that are added through upgrades and that require * initialization. * * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in * a contract, executing them in the right order is up to the developer or operator. */ modifier reinitializer(uint8 version) { require(!_initializing && _initialized < version, "Initializable: contract is already initialized"); _initialized = version; _initializing = true; _; _initializing = false; emit Initialized(version); } /** * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the * {initializer} and {reinitializer} modifiers, directly or indirectly. */ modifier onlyInitializing() { require(_initializing, "Initializable: contract is not initializing"); _; } /** * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call. * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized * to any version. It is recommended to use this to lock implementation contracts that are designed to be called * through proxies. */ function _disableInitializers() internal virtual { require(!_initializing, "Initializable: contract is initializing"); if (_initialized < type(uint8).max) { _initialized = type(uint8).max; emit Initialized(type(uint8).max); } } } /** * @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 ContextUpgradeable is Initializable { function __Context_init() internal onlyInitializing { } function __Context_init_unchained() internal onlyInitializing { } function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[50] private __gap; } /** * @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 OwnableUpgradeable is Initializable, ContextUpgradeable { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ function __Ownable_init() internal onlyInitializing { __Ownable_init_unchained(); } function __Ownable_init_unchained() internal onlyInitializing { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { 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); } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[49] private __gap; } interface IERC20 { event Approval( address indexed owner, address indexed spender, uint256 value ); event Transfer(address indexed from, address indexed to, uint256 value); function name() external view returns (string memory); function symbol() external view returns (string memory); function decimals() external view returns (uint8); function totalSupply() external view returns (uint256); function balanceOf(address owner) external view returns (uint256); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 value) external returns (bool); function transfer(address to, uint256 value) external returns (bool); function transferFrom( address from, address to, uint256 value ) external returns (bool); } library SafeMath { uint256 constant WAD = 10**18; uint256 constant RAY = 10**27; function wad() public pure returns (uint256) { return WAD; } function ray() public pure returns (uint256) { return RAY; } function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (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 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { // Solidity only automatically asserts when dividing by 0 require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } function min(uint256 a, uint256 b) internal pure returns (uint256) { return a <= b ? a : b; } function max(uint256 a, uint256 b) internal pure returns (uint256) { return a >= b ? a : b; } function sqrt(uint256 a) internal pure returns (uint256 b) { if (a > 3) { b = a; uint256 x = a / 2 + 1; while (x < b) { b = x; x = (a / x + x) / 2; } } else if (a != 0) { b = 1; } } function wmul(uint256 a, uint256 b) internal pure returns (uint256) { return mul(a, b) / WAD; } function wmulRound(uint256 a, uint256 b) internal pure returns (uint256) { return add(mul(a, b), WAD / 2) / WAD; } function rmul(uint256 a, uint256 b) internal pure returns (uint256) { return mul(a, b) / RAY; } function rmulRound(uint256 a, uint256 b) internal pure returns (uint256) { return add(mul(a, b), RAY / 2) / RAY; } function wdiv(uint256 a, uint256 b) internal pure returns (uint256) { return div(mul(a, WAD), b); } function wdivRound(uint256 a, uint256 b) internal pure returns (uint256) { return add(mul(a, WAD), b / 2) / b; } function rdiv(uint256 a, uint256 b) internal pure returns (uint256) { return div(mul(a, RAY), b); } function rdivRound(uint256 a, uint256 b) internal pure returns (uint256) { return add(mul(a, RAY), b / 2) / b; } function wpow(uint256 x, uint256 n) internal pure returns (uint256) { uint256 result = WAD; while (n > 0) { if (n % 2 != 0) { result = wmul(result, x); } x = wmul(x, x); n /= 2; } return result; } function rpow(uint256 x, uint256 n) internal pure returns (uint256) { uint256 result = RAY; while (n > 0) { if (n % 2 != 0) { result = rmul(result, x); } x = rmul(x, x); n /= 2; } return result; } function divCeil(uint256 a, uint256 b) internal pure returns (uint256) { uint256 quotient = div(a, b); uint256 remainder = a - quotient * b; if (remainder > 0) { return quotient + 1; } else { return quotient; } } } /** * @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) { // According to EIP-1052, 0x0 is the value returned for not-yet created accounts // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned // for accounts without code, i.e. `keccak256('')` bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; // solhint-disable-next-line no-inline-assembly assembly { codehash := extcodehash(account) } return (codehash != accountHash && codehash != 0x0); } /** * @dev Converts an `address` into `address payable`. Note that this is * simply a type cast: the actual underlying value is not changed. * * _Available since v2.4.0._ */ function toPayable(address account) internal pure returns (address payable) { return payable(account); } /** * @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]. * * _Available since v2.4.0._ */ function sendValue(address recipient, uint256 amount) internal { require( address(this).balance >= amount, "Address: insufficient balance" ); // solhint-disable-next-line avoid-call-value (bool success, ) = recipient.call{value: amount}(""); require( success, "Address: unable to send value, recipient may have reverted" ); } } 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()) } } } /** * @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); } /// @title Interface for DAI-style permits interface IDaiLikePermit { function permit( address holder, address spender, uint256 nonce, uint256 expiry, bool allowed, uint8 v, bytes32 r, bytes32 s ) external; } // File @1inch/solidity-utils/contracts/libraries/[email protected] 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) success := call(gas(), token, 0, data, 100, 0x0, 0x20) if success { switch returndatasize() case 0 { success := gt(extcodesize(token), 0) } default { success := 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(); } } function safeApprove(IERC20 token, address spender, uint256 value) internal { forceApprove(token, spender, value); } // 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) { success = _makeCalldataCall(token, IERC20Permit.permit.selector, permit); } else if (permit.length == 32 * 8) { 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 success) { /// @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) success := call(gas(), token, 0, data, 0x44, 0x0, 0x20) if success { switch returndatasize() case 0 { success := gt(extcodesize(token), 0) } default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) } } } } function _makeCalldataCall(IERC20 token, bytes4 selector, bytes calldata args) private returns(bool success) { /// @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) success := call(gas(), token, 0, data, len, 0x0, 0x20) if success { switch returndatasize() case 0 { success := gt(extcodesize(token), 0) } default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) } } } } } /// @title Handle authorizations in dex platform /// @notice Explain to an end user what this does /// @dev Explain to a developer any extra details contract TokenApprove is OwnableUpgradeable { using SafeERC20 for IERC20; address public tokenApproveProxy; function initialize(address _tokenApproveProxy) public initializer { __Ownable_init(); tokenApproveProxy = _tokenApproveProxy; } //------------------------------- //------- Events ---------------- //------------------------------- event ProxyUpdate(address indexed oldProxy, address indexed newProxy); //------------------------------- //------- Modifier -------------- //------------------------------- //-------------------------------- //------- Internal Functions ----- //-------------------------------- //--------------------------------- //------- Admin functions --------- //--------------------------------- function setApproveProxy(address _newTokenApproveProxy) external onlyOwner { emit ProxyUpdate(tokenApproveProxy, _newTokenApproveProxy); tokenApproveProxy = _newTokenApproveProxy; } //--------------------------------- //------- Users Functions -------- //--------------------------------- function claimTokens( address _token, address _who, address _dest, uint256 _amount ) external { require(msg.sender == tokenApproveProxy, "TokenApprove: Access restricted"); if (_amount > 0) { IERC20(_token).safeTransferFrom(_who, _dest, _amount); } } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"name":"SafeTransferFromFailed","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","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"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldProxy","type":"address"},{"indexed":true,"internalType":"address","name":"newProxy","type":"address"}],"name":"ProxyUpdate","type":"event"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"address","name":"_who","type":"address"},{"internalType":"address","name":"_dest","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"claimTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_tokenApproveProxy","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","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":"_newTokenApproveProxy","type":"address"}],"name":"setApproveProxy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"tokenApproveProxy","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
9c4d535b0000000000000000000000000000000000000000000000000000000000000000010000cbe27636f54fb33827dd1b2cb88790a36604b9b9f23eae0857b8812f9900000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000
Deployed Bytecode
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
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 31 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|---|---|---|---|---|
ZKSYNC | 100.00% | $0.999712 | 13.587 | $13.58 |
[ 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.