diff --git a/contracts/contracts/libraries/usdc/FiatTokenProxy.sol.flatten b/contracts/contracts/libraries/usdc/FiatTokenProxy.sol.flatten new file mode 100644 index 000000000..2f9e11121 --- /dev/null +++ b/contracts/contracts/libraries/usdc/FiatTokenProxy.sol.flatten @@ -0,0 +1,576 @@ +// SPDX-License-Identifier: Apache-2.0 +pragma solidity <0.8.0 =0.6.12 >=0.6.2; + +// contracts/upgradeability/Proxy.sol +/** + * Copyright 2023 Circle Internet Group, Inc. All rights reserved. + * + + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @notice Implements delegation of calls to other contracts, with proper + * forwarding of return values and bubbling of failures. + * It defines a fallback function that delegates all calls to the address + * returned by the abstract _implementation() internal function. + * @dev Forked from https://github.com/zeppelinos/zos-lib/blob/8a16ef3ad17ec7430e3a9d2b5e3f39b8204f8c8d/contracts/upgradeability/Proxy.sol + * Modifications: + * 1. Reformat and conform to Solidity 0.6 syntax (5/13/20) + */ +abstract contract Proxy { + /** + * @dev Fallback function. + * Implemented entirely in `_fallback`. + */ + fallback() external payable { + _fallback(); + } + + /** + * @return The Address of the implementation. + */ + function _implementation() internal virtual view returns (address); + + /** + * @dev Delegates execution to an implementation contract. + * This is a low level function that doesn't return to its internal call site. + * It will return to the external caller whatever the implementation returns. + * @param implementation Address to delegate. + */ + function _delegate(address implementation) internal { + assembly { + // Copy msg.data. We take full control of memory in this inline assembly + // block because it will not return to Solidity code. We overwrite the + // Solidity scratch pad at memory position 0. + calldatacopy(0, 0, calldatasize()) + + // Call the implementation. + // out and outsize are 0 because we don't know the size yet. + let result := delegatecall( + gas(), + implementation, + 0, + calldatasize(), + 0, + 0 + ) + + // Copy the returned data. + returndatacopy(0, 0, returndatasize()) + + switch result + // delegatecall returns 0 on error. + case 0 { + revert(0, returndatasize()) + } + default { + return(0, returndatasize()) + } + } + } + + /** + * @dev Function that is run as the first thing in the fallback function. + * Can be redefined in derived contracts to add functionality. + * Redefinitions must call super._willFallback(). + */ + function _willFallback() internal virtual {} + + /** + * @dev fallback implementation. + * Extracted to enable manual triggering. + */ + function _fallback() internal { + _willFallback(); + _delegate(_implementation()); + } +} + +// node_modules/@openzeppelin/contracts/utils/Address.sol + +/** + * @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); + } + } + } +} + +// contracts/upgradeability/UpgradeabilityProxy.sol +/** + * Copyright 2023 Circle Internet Group, Inc. All rights reserved. + * + + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @notice This contract implements a proxy that allows to change the + * implementation address to which it will delegate. + * Such a change is called an implementation upgrade. + * @dev Forked from https://github.com/zeppelinos/zos-lib/blob/8a16ef3ad17ec7430e3a9d2b5e3f39b8204f8c8d/contracts/upgradeability/UpgradeabilityProxy.sol + * Modifications: + * 1. Reformat, conform to Solidity 0.6 syntax, and add error messages (5/13/20) + * 2. Use Address utility library from the latest OpenZeppelin (5/13/20) + */ +contract UpgradeabilityProxy is Proxy { + /** + * @dev Emitted when the implementation is upgraded. + * @param implementation Address of the new implementation. + */ + event Upgraded(address implementation); + + /** + * @dev Storage slot with the address of the current implementation. + * This is the keccak-256 hash of "org.zeppelinos.proxy.implementation", and is + * validated in the constructor. + */ + bytes32 + private constant IMPLEMENTATION_SLOT = 0x7050c9e0f4ca769c69bd3a8ef740bc37934f8e2c036e5a723fd8ee048ed3f8c3; + + /** + * @dev Contract constructor. + * @param implementationContract Address of the initial implementation. + */ + constructor(address implementationContract) public { + assert( + IMPLEMENTATION_SLOT == + keccak256("org.zeppelinos.proxy.implementation") + ); + + _setImplementation(implementationContract); + } + + /** + * @dev Returns the current implementation. + * @return impl Address of the current implementation + */ + function _implementation() internal override view returns (address impl) { + bytes32 slot = IMPLEMENTATION_SLOT; + assembly { + impl := sload(slot) + } + } + + /** + * @dev Upgrades the proxy to a new implementation. + * @param newImplementation Address of the new implementation. + */ + function _upgradeTo(address newImplementation) internal { + _setImplementation(newImplementation); + emit Upgraded(newImplementation); + } + + /** + * @dev Sets the implementation address of the proxy. + * @param newImplementation Address of the new implementation. + */ + function _setImplementation(address newImplementation) private { + require( + Address.isContract(newImplementation), + "Cannot set a proxy implementation to a non-contract address" + ); + + bytes32 slot = IMPLEMENTATION_SLOT; + + assembly { + sstore(slot, newImplementation) + } + } +} + +// contracts/upgradeability/AdminUpgradeabilityProxy.sol +/** + * Copyright 2023 Circle Internet Group, Inc. All rights reserved. + * + + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @notice This contract combines an upgradeability proxy with an authorization + * mechanism for administrative tasks. + * @dev Forked from https://github.com/zeppelinos/zos-lib/blob/8a16ef3ad17ec7430e3a9d2b5e3f39b8204f8c8d/contracts/upgradeability/AdminUpgradeabilityProxy.sol + * Modifications: + * 1. Reformat, conform to Solidity 0.6 syntax, and add error messages (5/13/20) + * 2. Remove ifAdmin modifier from admin() and implementation() (5/13/20) + */ +contract AdminUpgradeabilityProxy is UpgradeabilityProxy { + /** + * @dev Emitted when the administration has been transferred. + * @param previousAdmin Address of the previous admin. + * @param newAdmin Address of the new admin. + */ + event AdminChanged(address previousAdmin, address newAdmin); + + /** + * @dev Storage slot with the admin of the contract. + * This is the keccak-256 hash of "org.zeppelinos.proxy.admin", and is + * validated in the constructor. + */ + bytes32 + private constant ADMIN_SLOT = 0x10d6a54a4754c8869d6886b5f5d7fbfa5b4522237ea5c60d11bc4e7a1ff9390b; + + /** + * @dev Modifier to check whether the `msg.sender` is the admin. + * If it is, it will run the function. Otherwise, it will delegate the call + * to the implementation. + */ + modifier ifAdmin() { + if (msg.sender == _admin()) { + _; + } else { + _fallback(); + } + } + + /** + * @dev Contract constructor. + * It sets the `msg.sender` as the proxy administrator. + * @param implementationContract address of the initial implementation. + */ + constructor(address implementationContract) + public + UpgradeabilityProxy(implementationContract) + { + assert(ADMIN_SLOT == keccak256("org.zeppelinos.proxy.admin")); + + _setAdmin(msg.sender); + } + + /** + * @return The address of the proxy admin. + */ + function admin() external view returns (address) { + return _admin(); + } + + /** + * @return The address of the implementation. + */ + function implementation() external view returns (address) { + return _implementation(); + } + + /** + * @dev Changes the admin of the proxy. + * Only the current admin can call this function. + * @param newAdmin Address to transfer proxy administration to. + */ + function changeAdmin(address newAdmin) external ifAdmin { + require( + newAdmin != address(0), + "Cannot change the admin of a proxy to the zero address" + ); + emit AdminChanged(_admin(), newAdmin); + _setAdmin(newAdmin); + } + + /** + * @dev Upgrade the backing implementation of the proxy. + * Only the admin can call this function. + * @param newImplementation Address of the new implementation. + */ + function upgradeTo(address newImplementation) external ifAdmin { + _upgradeTo(newImplementation); + } + + /** + * @dev Upgrade the backing implementation of the proxy and call a function + * on the new implementation. + * This is useful to initialize the proxied contract. + * @param newImplementation Address of the new implementation. + * @param data Data to send as msg.data in the low level call. + * It should include the signature and the parameters of the function to be + * called, as described in + * https://solidity.readthedocs.io/en/develop/abi-spec.html#function-selector-and-argument-encoding. + */ + function upgradeToAndCall(address newImplementation, bytes calldata data) + external + payable + ifAdmin + { + _upgradeTo(newImplementation); + // prettier-ignore + // solhint-disable-next-line avoid-low-level-calls + (bool success,) = address(this).call{value: msg.value}(data); + // solhint-disable-next-line reason-string + require(success); + } + + /** + * @return adm The admin slot. + */ + function _admin() internal view returns (address adm) { + bytes32 slot = ADMIN_SLOT; + + assembly { + adm := sload(slot) + } + } + + /** + * @dev Sets the address of the proxy admin. + * @param newAdmin Address of the new proxy admin. + */ + function _setAdmin(address newAdmin) internal { + bytes32 slot = ADMIN_SLOT; + + assembly { + sstore(slot, newAdmin) + } + } + + /** + * @dev Only fall back when the sender is not the admin. + */ + function _willFallback() internal override { + require( + msg.sender != _admin(), + "Cannot call fallback function from the proxy admin" + ); + super._willFallback(); + } +} + +// contracts/v1/FiatTokenProxy.sol +/** + * Copyright 2023 Circle Internet Group, Inc. All rights reserved. + * + + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @title FiatTokenProxy + * @dev This contract proxies FiatToken calls and enables FiatToken upgrades + */ +contract FiatTokenProxy is AdminUpgradeabilityProxy { + constructor(address implementationContract) + public + AdminUpgradeabilityProxy(implementationContract) + {} +} diff --git a/contracts/contracts/libraries/usdc/FiatTokenV2_2.sol.flatten b/contracts/contracts/libraries/usdc/FiatTokenV2_2.sol.flatten new file mode 100644 index 000000000..9f8d3d419 --- /dev/null +++ b/contracts/contracts/libraries/usdc/FiatTokenV2_2.sol.flatten @@ -0,0 +1,2876 @@ +// SPDX-License-Identifier: Apache-2.0 +pragma solidity <0.8.0 =0.6.12 >=0.6.0 >=0.6.2; + +// contracts/interface/IERC1271.sol +/** + * Copyright 2023 Circle Internet Group, Inc. All rights reserved. + * + + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @dev Interface of the ERC1271 standard signature validation method for + * contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271]. + */ +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 the provided data hash + * @return magicValue bytes4 magic value 0x1626ba7e when function passes + */ + function isValidSignature(bytes32 hash, bytes memory signature) + external + view + returns (bytes4 magicValue); +} + +// contracts/util/ECRecover.sol +/** + * Copyright 2023 Circle Internet Group, Inc. All rights reserved. + * + + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @title ECRecover + * @notice A library that provides a safe ECDSA recovery function + */ +library ECRecover { + /** + * @notice Recover signer's address from a signed message + * @dev Adapted from: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/65e4ffde586ec89af3b7e9140bdc9235d1254853/contracts/cryptography/ECDSA.sol + * Modifications: Accept v, r, and s as separate arguments + * @param digest Keccak-256 hash digest of the signed message + * @param v v of the signature + * @param r r of the signature + * @param s s of the signature + * @return Signer address + */ + function recover( + bytes32 digest, + uint8 v, + bytes32 r, + bytes32 s + ) internal pure returns (address) { + // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature + // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines + // the valid range for s in (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): v ∈ {27, 28}. Most + // signatures from current libraries generate a unique signature with an s-value in the lower half order. + // + // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value + // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or + // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept + // these malleable signatures as well. + if ( + uint256(s) > + 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0 + ) { + revert("ECRecover: invalid signature 's' value"); + } + + if (v != 27 && v != 28) { + revert("ECRecover: invalid signature 'v' value"); + } + + // If the signature is valid (and not malleable), return the signer address + address signer = ecrecover(digest, v, r, s); + require(signer != address(0), "ECRecover: invalid signature"); + + return signer; + } + + /** + * @notice Recover signer's address from a signed message + * @dev Adapted from: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/0053ee040a7ff1dbc39691c9e67a69f564930a88/contracts/utils/cryptography/ECDSA.sol + * @param digest Keccak-256 hash digest of the signed message + * @param signature Signature byte array associated with hash + * @return Signer address + */ + function recover(bytes32 digest, bytes memory signature) + internal + pure + returns (address) + { + require(signature.length == 65, "ECRecover: invalid signature length"); + + bytes32 r; + bytes32 s; + uint8 v; + + // ecrecover takes the signature parameters, and the only way to get them + // currently is to use assembly. + /// @solidity memory-safe-assembly + assembly { + r := mload(add(signature, 0x20)) + s := mload(add(signature, 0x40)) + v := byte(0, mload(add(signature, 0x60))) + } + return recover(digest, v, r, s); + } +} + +// contracts/util/EIP712.sol +/** + * Copyright 2023 Circle Internet Group, Inc. All rights reserved. + * + + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @title EIP712 + * @notice A library that provides EIP712 helper functions + */ +library EIP712 { + /** + * @notice Make EIP712 domain separator + * @param name Contract name + * @param version Contract version + * @param chainId Blockchain ID + * @return Domain separator + */ + function makeDomainSeparator( + string memory name, + string memory version, + uint256 chainId + ) internal view returns (bytes32) { + return + keccak256( + abi.encode( + // keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)") + 0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f, + keccak256(bytes(name)), + keccak256(bytes(version)), + chainId, + address(this) + ) + ); + } + + /** + * @notice Make EIP712 domain separator + * @param name Contract name + * @param version Contract version + * @return Domain separator + */ + function makeDomainSeparator(string memory name, string memory version) + internal + view + returns (bytes32) + { + uint256 chainId; + assembly { + chainId := chainid() + } + return makeDomainSeparator(name, version, chainId); + } +} + +// contracts/util/MessageHashUtils.sol +/** + * Copyright 2023 Circle Internet Group, Inc. All rights reserved. + * + + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing. + * + * The library provides methods for generating a hash of a message that conforms to the + * https://eips.ethereum.org/EIPS/eip-191[EIP 191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712] + * specifications. + */ +library MessageHashUtils { + /** + * @dev Returns the keccak256 digest of an EIP-712 typed data (EIP-191 version `0x01`). + * Adapted from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/21bb89ef5bfc789b9333eb05e3ba2b7b284ac77c/contracts/utils/cryptography/MessageHashUtils.sol + * + * The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with + * `\x19\x01` and hashing the result. It corresponds to the hash signed by the + * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712. + * + * @param domainSeparator Domain separator + * @param structHash Hashed EIP-712 data struct + * @return digest The keccak256 digest of an EIP-712 typed data + */ + function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) + internal + pure + returns (bytes32 digest) + { + assembly { + let ptr := mload(0x40) + mstore(ptr, "\x19\x01") + mstore(add(ptr, 0x02), domainSeparator) + mstore(add(ptr, 0x22), structHash) + digest := keccak256(ptr, 0x42) + } + } +} + +// contracts/v1/Ownable.sol +/** + + * + * Copyright (c) 2018 zOS Global Limited. + * Copyright (c) 2018-2020 CENTRE SECZ + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +/** + * @notice The Ownable contract has an owner address, and provides basic + * authorization control functions + * @dev Forked from https://github.com/OpenZeppelin/openzeppelin-labs/blob/3887ab77b8adafba4a26ace002f3a684c1a3388b/upgradeability_ownership/contracts/ownership/Ownable.sol + * Modifications: + * 1. Consolidate OwnableStorage into this contract (7/13/18) + * 2. Reformat, conform to Solidity 0.6 syntax, and add error messages (5/13/20) + * 3. Make public functions external (5/27/20) + */ +contract Ownable { + // Owner of the contract + address private _owner; + + /** + * @dev Event to show ownership has been transferred + * @param previousOwner representing the address of the previous owner + * @param newOwner representing the address of the new owner + */ + event OwnershipTransferred(address previousOwner, address newOwner); + + /** + * @dev The constructor sets the original owner of the contract to the sender account. + */ + constructor() public { + setOwner(msg.sender); + } + + /** + * @dev Tells the address of the owner + * @return the address of the owner + */ + function owner() external view returns (address) { + return _owner; + } + + /** + * @dev Sets a new owner address + */ + function setOwner(address newOwner) internal { + _owner = newOwner; + } + + /** + * @dev Throws if called by any account other than the owner. + */ + modifier onlyOwner() { + require(msg.sender == _owner, "Ownable: caller is not the owner"); + _; + } + + /** + * @dev Allows the current owner to transfer control of the contract to a newOwner. + * @param newOwner The address to transfer ownership to. + */ + function transferOwnership(address newOwner) external onlyOwner { + require( + newOwner != address(0), + "Ownable: new owner is the zero address" + ); + emit OwnershipTransferred(_owner, newOwner); + setOwner(newOwner); + } +} + +// contracts/v2/EIP712Domain.sol +/** + * Copyright 2023 Circle Internet Group, Inc. All rights reserved. + * + + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// solhint-disable func-name-mixedcase + +/** + * @title EIP712 Domain + */ +contract EIP712Domain { + // was originally DOMAIN_SEPARATOR + // but that has been moved to a method so we can override it in V2_2+ + bytes32 internal _DEPRECATED_CACHED_DOMAIN_SEPARATOR; + + /** + * @notice Get the EIP712 Domain Separator. + * @return The bytes32 EIP712 domain separator. + */ + function DOMAIN_SEPARATOR() external view returns (bytes32) { + return _domainSeparator(); + } + + /** + * @dev Internal method to get the EIP712 Domain Separator. + * @return The bytes32 EIP712 domain separator. + */ + function _domainSeparator() internal virtual view returns (bytes32) { + return _DEPRECATED_CACHED_DOMAIN_SEPARATOR; + } +} + +// node_modules/@openzeppelin/contracts/math/SafeMath.sol + +/** + * @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; + } +} + +// node_modules/@openzeppelin/contracts/token/ERC20/IERC20.sol + +/** + * @dev Interface of the ERC20 standard as defined in the EIP. + */ +interface IERC20 { + /** + * @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 `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); +} + +// node_modules/@openzeppelin/contracts/utils/Address.sol + +/** + * @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); + } + } + } +} + +// contracts/v1/AbstractFiatTokenV1.sol +/** + * Copyright 2023 Circle Internet Group, Inc. All rights reserved. + * + + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +abstract contract AbstractFiatTokenV1 is IERC20 { + function _approve( + address owner, + address spender, + uint256 value + ) internal virtual; + + function _transfer( + address from, + address to, + uint256 value + ) internal virtual; +} + +// contracts/v1/Blacklistable.sol +/** + * Copyright 2023 Circle Internet Group, Inc. All rights reserved. + * + + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @title Blacklistable Token + * @dev Allows accounts to be blacklisted by a "blacklister" role + */ +abstract contract Blacklistable is Ownable { + address public blacklister; + mapping(address => bool) internal _deprecatedBlacklisted; + + event Blacklisted(address indexed _account); + event UnBlacklisted(address indexed _account); + event BlacklisterChanged(address indexed newBlacklister); + + /** + * @dev Throws if called by any account other than the blacklister. + */ + modifier onlyBlacklister() { + require( + msg.sender == blacklister, + "Blacklistable: caller is not the blacklister" + ); + _; + } + + /** + * @dev Throws if argument account is blacklisted. + * @param _account The address to check. + */ + modifier notBlacklisted(address _account) { + require( + !_isBlacklisted(_account), + "Blacklistable: account is blacklisted" + ); + _; + } + + /** + * @notice Checks if account is blacklisted. + * @param _account The address to check. + * @return True if the account is blacklisted, false if the account is not blacklisted. + */ + function isBlacklisted(address _account) external view returns (bool) { + return _isBlacklisted(_account); + } + + /** + * @notice Adds account to blacklist. + * @param _account The address to blacklist. + */ + function blacklist(address _account) external onlyBlacklister { + _blacklist(_account); + emit Blacklisted(_account); + } + + /** + * @notice Removes account from blacklist. + * @param _account The address to remove from the blacklist. + */ + function unBlacklist(address _account) external onlyBlacklister { + _unBlacklist(_account); + emit UnBlacklisted(_account); + } + + /** + * @notice Updates the blacklister address. + * @param _newBlacklister The address of the new blacklister. + */ + function updateBlacklister(address _newBlacklister) external onlyOwner { + require( + _newBlacklister != address(0), + "Blacklistable: new blacklister is the zero address" + ); + blacklister = _newBlacklister; + emit BlacklisterChanged(blacklister); + } + + /** + * @dev Checks if account is blacklisted. + * @param _account The address to check. + * @return true if the account is blacklisted, false otherwise. + */ + function _isBlacklisted(address _account) + internal + virtual + view + returns (bool); + + /** + * @dev Helper method that blacklists an account. + * @param _account The address to blacklist. + */ + function _blacklist(address _account) internal virtual; + + /** + * @dev Helper method that unblacklists an account. + * @param _account The address to unblacklist. + */ + function _unBlacklist(address _account) internal virtual; +} + +// contracts/v1/Pausable.sol +/** + + * + * Copyright (c) 2016 Smart Contract Solutions, Inc. + * Copyright (c) 2018-2020 CENTRE SECZ + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +/** + * @notice Base contract which allows children to implement an emergency stop + * mechanism + * @dev Forked from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/feb665136c0dae9912e08397c1a21c4af3651ef3/contracts/lifecycle/Pausable.sol + * Modifications: + * 1. Added pauser role, switched pause/unpause to be onlyPauser (6/14/2018) + * 2. Removed whenNotPause/whenPaused from pause/unpause (6/14/2018) + * 3. Removed whenPaused (6/14/2018) + * 4. Switches ownable library to use ZeppelinOS (7/12/18) + * 5. Remove constructor (7/13/18) + * 6. Reformat, conform to Solidity 0.6 syntax and add error messages (5/13/20) + * 7. Make public functions external (5/27/20) + */ +contract Pausable is Ownable { + event Pause(); + event Unpause(); + event PauserChanged(address indexed newAddress); + + address public pauser; + bool public paused = false; + + /** + * @dev Modifier to make a function callable only when the contract is not paused. + */ + modifier whenNotPaused() { + require(!paused, "Pausable: paused"); + _; + } + + /** + * @dev throws if called by any account other than the pauser + */ + modifier onlyPauser() { + require(msg.sender == pauser, "Pausable: caller is not the pauser"); + _; + } + + /** + * @dev called by the owner to pause, triggers stopped state + */ + function pause() external onlyPauser { + paused = true; + emit Pause(); + } + + /** + * @dev called by the owner to unpause, returns to normal state + */ + function unpause() external onlyPauser { + paused = false; + emit Unpause(); + } + + /** + * @notice Updates the pauser address. + * @param _newPauser The address of the new pauser. + */ + function updatePauser(address _newPauser) external onlyOwner { + require( + _newPauser != address(0), + "Pausable: new pauser is the zero address" + ); + pauser = _newPauser; + emit PauserChanged(pauser); + } +} + +// contracts/util/SignatureChecker.sol +/** + * Copyright 2023 Circle Internet Group, Inc. All rights reserved. + * + + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @dev Signature verification helper that can be used instead of `ECRecover.recover` to seamlessly support both ECDSA + * signatures from externally owned accounts (EOAs) as well as ERC1271 signatures from smart contract wallets. + * + * Adapted from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/21bb89ef5bfc789b9333eb05e3ba2b7b284ac77c/contracts/utils/cryptography/SignatureChecker.sol + */ +library SignatureChecker { + /** + * @dev Checks if a signature is valid for a given signer and data hash. If the signer is a smart contract, the + * signature is validated against that smart contract using ERC1271, otherwise it's validated using `ECRecover.recover`. + * @param signer Address of the claimed signer + * @param digest Keccak-256 hash digest of the signed message + * @param signature Signature byte array associated with hash + */ + function isValidSignatureNow( + address signer, + bytes32 digest, + bytes memory signature + ) external view returns (bool) { + if (!isContract(signer)) { + return ECRecover.recover(digest, signature) == signer; + } + return isValidERC1271SignatureNow(signer, digest, signature); + } + + /** + * @dev Checks if a signature is valid for a given signer and data hash. The signature is validated + * against the signer smart contract using ERC1271. + * @param signer Address of the claimed signer + * @param digest Keccak-256 hash digest of the signed message + * @param signature Signature byte array associated with hash + * + * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus + * change through time. It could return true at block N and false at block N+1 (or the opposite). + */ + function isValidERC1271SignatureNow( + address signer, + bytes32 digest, + bytes memory signature + ) internal view returns (bool) { + (bool success, bytes memory result) = signer.staticcall( + abi.encodeWithSelector( + IERC1271.isValidSignature.selector, + digest, + signature + ) + ); + return (success && + result.length >= 32 && + abi.decode(result, (bytes32)) == + bytes32(IERC1271.isValidSignature.selector)); + } + + /** + * @dev Checks if the input address is a smart contract. + */ + function isContract(address addr) internal view returns (bool) { + uint256 size; + assembly { + size := extcodesize(addr) + } + return size > 0; + } +} + +// contracts/v2/AbstractFiatTokenV2.sol +/** + * Copyright 2023 Circle Internet Group, Inc. All rights reserved. + * + + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +abstract contract AbstractFiatTokenV2 is AbstractFiatTokenV1 { + function _increaseAllowance( + address owner, + address spender, + uint256 increment + ) internal virtual; + + function _decreaseAllowance( + address owner, + address spender, + uint256 decrement + ) internal virtual; +} + +// node_modules/@openzeppelin/contracts/token/ERC20/SafeERC20.sol + +/** + * @title SafeERC20 + * @dev Wrappers around ERC20 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 SafeERC20 for IERC20;` statement to your contract, + * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. + */ +library SafeERC20 { + using SafeMath for uint256; + using Address for address; + + function safeTransfer(IERC20 token, address to, uint256 value) internal { + _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); + } + + function safeTransferFrom(IERC20 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 + * {IERC20-approve}, and its usage is discouraged. + * + * Whenever possible, use {safeIncreaseAllowance} and + * {safeDecreaseAllowance} instead. + */ + function safeApprove(IERC20 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), + "SafeERC20: approve from non-zero to non-zero allowance" + ); + _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); + } + + function safeIncreaseAllowance(IERC20 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(IERC20 token, address spender, uint256 value) internal { + uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: 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(IERC20 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, "SafeERC20: low-level call failed"); + if (returndata.length > 0) { // Return data is optional + // solhint-disable-next-line max-line-length + require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); + } + } +} + +// contracts/v1.1/Rescuable.sol +/** + * Copyright 2023 Circle Internet Group, Inc. All rights reserved. + * + + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +contract Rescuable is Ownable { + using SafeERC20 for IERC20; + + address private _rescuer; + + event RescuerChanged(address indexed newRescuer); + + /** + * @notice Returns current rescuer + * @return Rescuer's address + */ + function rescuer() external view returns (address) { + return _rescuer; + } + + /** + * @notice Revert if called by any account other than the rescuer. + */ + modifier onlyRescuer() { + require(msg.sender == _rescuer, "Rescuable: caller is not the rescuer"); + _; + } + + /** + * @notice Rescue ERC20 tokens locked up in this contract. + * @param tokenContract ERC20 token contract address + * @param to Recipient address + * @param amount Amount to withdraw + */ + function rescueERC20( + IERC20 tokenContract, + address to, + uint256 amount + ) external onlyRescuer { + tokenContract.safeTransfer(to, amount); + } + + /** + * @notice Updates the rescuer address. + * @param newRescuer The address of the new rescuer. + */ + function updateRescuer(address newRescuer) external onlyOwner { + require( + newRescuer != address(0), + "Rescuable: new rescuer is the zero address" + ); + _rescuer = newRescuer; + emit RescuerChanged(newRescuer); + } +} + +// contracts/v1/FiatTokenV1.sol +/** + * Copyright 2023 Circle Internet Group, Inc. All rights reserved. + * + + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @title FiatToken + * @dev ERC20 Token backed by fiat reserves + */ +contract FiatTokenV1 is AbstractFiatTokenV1, Ownable, Pausable, Blacklistable { + using SafeMath for uint256; + + string public name; + string public symbol; + uint8 public decimals; + string public currency; + address public masterMinter; + bool internal initialized; + + /// @dev A mapping that stores the balance and blacklist states for a given address. + /// The first bit defines whether the address is blacklisted (1 if blacklisted, 0 otherwise). + /// The last 255 bits define the balance for the address. + mapping(address => uint256) internal balanceAndBlacklistStates; + mapping(address => mapping(address => uint256)) internal allowed; + uint256 internal totalSupply_ = 0; + mapping(address => bool) internal minters; + mapping(address => uint256) internal minterAllowed; + + event Mint(address indexed minter, address indexed to, uint256 amount); + event Burn(address indexed burner, uint256 amount); + event MinterConfigured(address indexed minter, uint256 minterAllowedAmount); + event MinterRemoved(address indexed oldMinter); + event MasterMinterChanged(address indexed newMasterMinter); + + /** + * @notice Initializes the fiat token contract. + * @param tokenName The name of the fiat token. + * @param tokenSymbol The symbol of the fiat token. + * @param tokenCurrency The fiat currency that the token represents. + * @param tokenDecimals The number of decimals that the token uses. + * @param newMasterMinter The masterMinter address for the fiat token. + * @param newPauser The pauser address for the fiat token. + * @param newBlacklister The blacklister address for the fiat token. + * @param newOwner The owner of the fiat token. + */ + function initialize( + string memory tokenName, + string memory tokenSymbol, + string memory tokenCurrency, + uint8 tokenDecimals, + address newMasterMinter, + address newPauser, + address newBlacklister, + address newOwner + ) public { + require(!initialized, "FiatToken: contract is already initialized"); + require( + newMasterMinter != address(0), + "FiatToken: new masterMinter is the zero address" + ); + require( + newPauser != address(0), + "FiatToken: new pauser is the zero address" + ); + require( + newBlacklister != address(0), + "FiatToken: new blacklister is the zero address" + ); + require( + newOwner != address(0), + "FiatToken: new owner is the zero address" + ); + + name = tokenName; + symbol = tokenSymbol; + currency = tokenCurrency; + decimals = tokenDecimals; + masterMinter = newMasterMinter; + pauser = newPauser; + blacklister = newBlacklister; + setOwner(newOwner); + initialized = true; + } + + /** + * @dev Throws if called by any account other than a minter. + */ + modifier onlyMinters() { + require(minters[msg.sender], "FiatToken: caller is not a minter"); + _; + } + + /** + * @notice Mints fiat tokens to an address. + * @param _to The address that will receive the minted tokens. + * @param _amount The amount of tokens to mint. Must be less than or equal + * to the minterAllowance of the caller. + * @return True if the operation was successful. + */ + function mint(address _to, uint256 _amount) + external + whenNotPaused + onlyMinters + notBlacklisted(msg.sender) + notBlacklisted(_to) + returns (bool) + { + require(_to != address(0), "FiatToken: mint to the zero address"); + require(_amount > 0, "FiatToken: mint amount not greater than 0"); + + uint256 mintingAllowedAmount = minterAllowed[msg.sender]; + require( + _amount <= mintingAllowedAmount, + "FiatToken: mint amount exceeds minterAllowance" + ); + + totalSupply_ = totalSupply_.add(_amount); + _setBalance(_to, _balanceOf(_to).add(_amount)); + minterAllowed[msg.sender] = mintingAllowedAmount.sub(_amount); + emit Mint(msg.sender, _to, _amount); + emit Transfer(address(0), _to, _amount); + return true; + } + + /** + * @dev Throws if called by any account other than the masterMinter + */ + modifier onlyMasterMinter() { + require( + msg.sender == masterMinter, + "FiatToken: caller is not the masterMinter" + ); + _; + } + + /** + * @notice Gets the minter allowance for an account. + * @param minter The address to check. + * @return The remaining minter allowance for the account. + */ + function minterAllowance(address minter) external view returns (uint256) { + return minterAllowed[minter]; + } + + /** + * @notice Checks if an account is a minter. + * @param account The address to check. + * @return True if the account is a minter, false if the account is not a minter. + */ + function isMinter(address account) external view returns (bool) { + return minters[account]; + } + + /** + * @notice Gets the remaining amount of fiat tokens a spender is allowed to transfer on + * behalf of the token owner. + * @param owner The token owner's address. + * @param spender The spender's address. + * @return The remaining allowance. + */ + function allowance(address owner, address spender) + external + override + view + returns (uint256) + { + return allowed[owner][spender]; + } + + /** + * @notice Gets the totalSupply of the fiat token. + * @return The totalSupply of the fiat token. + */ + function totalSupply() external override view returns (uint256) { + return totalSupply_; + } + + /** + * @notice Gets the fiat token balance of an account. + * @param account The address to check. + * @return balance The fiat token balance of the account. + */ + function balanceOf(address account) + external + override + view + returns (uint256) + { + return _balanceOf(account); + } + + /** + * @notice Sets a fiat token allowance for a spender to spend on behalf of the caller. + * @param spender The spender's address. + * @param value The allowance amount. + * @return True if the operation was successful. + */ + function approve(address spender, uint256 value) + external + virtual + override + whenNotPaused + notBlacklisted(msg.sender) + notBlacklisted(spender) + returns (bool) + { + _approve(msg.sender, spender, value); + return true; + } + + /** + * @dev Internal function to set allowance. + * @param owner Token owner's address. + * @param spender Spender's address. + * @param value Allowance amount. + */ + function _approve( + address owner, + address spender, + uint256 value + ) internal override { + require(owner != address(0), "ERC20: approve from the zero address"); + require(spender != address(0), "ERC20: approve to the zero address"); + allowed[owner][spender] = value; + emit Approval(owner, spender, value); + } + + /** + * @notice Transfers tokens from an address to another by spending the caller's allowance. + * @dev The caller must have some fiat token allowance on the payer's tokens. + * @param from Payer's address. + * @param to Payee's address. + * @param value Transfer amount. + * @return True if the operation was successful. + */ + function transferFrom( + address from, + address to, + uint256 value + ) + external + override + whenNotPaused + notBlacklisted(msg.sender) + notBlacklisted(from) + notBlacklisted(to) + returns (bool) + { + require( + value <= allowed[from][msg.sender], + "ERC20: transfer amount exceeds allowance" + ); + _transfer(from, to, value); + allowed[from][msg.sender] = allowed[from][msg.sender].sub(value); + return true; + } + + /** + * @notice Transfers tokens from the caller. + * @param to Payee's address. + * @param value Transfer amount. + * @return True if the operation was successful. + */ + function transfer(address to, uint256 value) + external + override + whenNotPaused + notBlacklisted(msg.sender) + notBlacklisted(to) + returns (bool) + { + _transfer(msg.sender, to, value); + return true; + } + + /** + * @dev Internal function to process transfers. + * @param from Payer's address. + * @param to Payee's address. + * @param value Transfer amount. + */ + function _transfer( + address from, + address to, + uint256 value + ) internal override { + require(from != address(0), "ERC20: transfer from the zero address"); + require(to != address(0), "ERC20: transfer to the zero address"); + require( + value <= _balanceOf(from), + "ERC20: transfer amount exceeds balance" + ); + + _setBalance(from, _balanceOf(from).sub(value)); + _setBalance(to, _balanceOf(to).add(value)); + emit Transfer(from, to, value); + } + + /** + * @notice Adds or updates a new minter with a mint allowance. + * @param minter The address of the minter. + * @param minterAllowedAmount The minting amount allowed for the minter. + * @return True if the operation was successful. + */ + function configureMinter(address minter, uint256 minterAllowedAmount) + external + whenNotPaused + onlyMasterMinter + returns (bool) + { + minters[minter] = true; + minterAllowed[minter] = minterAllowedAmount; + emit MinterConfigured(minter, minterAllowedAmount); + return true; + } + + /** + * @notice Removes a minter. + * @param minter The address of the minter to remove. + * @return True if the operation was successful. + */ + function removeMinter(address minter) + external + onlyMasterMinter + returns (bool) + { + minters[minter] = false; + minterAllowed[minter] = 0; + emit MinterRemoved(minter); + return true; + } + + /** + * @notice Allows a minter to burn some of its own tokens. + * @dev The caller must be a minter, must not be blacklisted, and the amount to burn + * should be less than or equal to the account's balance. + * @param _amount the amount of tokens to be burned. + */ + function burn(uint256 _amount) + external + whenNotPaused + onlyMinters + notBlacklisted(msg.sender) + { + uint256 balance = _balanceOf(msg.sender); + require(_amount > 0, "FiatToken: burn amount not greater than 0"); + require(balance >= _amount, "FiatToken: burn amount exceeds balance"); + + totalSupply_ = totalSupply_.sub(_amount); + _setBalance(msg.sender, balance.sub(_amount)); + emit Burn(msg.sender, _amount); + emit Transfer(msg.sender, address(0), _amount); + } + + /** + * @notice Updates the master minter address. + * @param _newMasterMinter The address of the new master minter. + */ + function updateMasterMinter(address _newMasterMinter) external onlyOwner { + require( + _newMasterMinter != address(0), + "FiatToken: new masterMinter is the zero address" + ); + masterMinter = _newMasterMinter; + emit MasterMinterChanged(masterMinter); + } + + /** + * + */ + function _blacklist(address _account) internal override { + _setBlacklistState(_account, true); + } + + /** + * + */ + function _unBlacklist(address _account) internal override { + _setBlacklistState(_account, false); + } + + /** + * @dev Helper method that sets the blacklist state of an account. + * @param _account The address of the account. + * @param _shouldBlacklist True if the account should be blacklisted, false if the account should be unblacklisted. + */ + function _setBlacklistState(address _account, bool _shouldBlacklist) + internal + virtual + { + _deprecatedBlacklisted[_account] = _shouldBlacklist; + } + + /** + * @dev Helper method that sets the balance of an account. + * @param _account The address of the account. + * @param _balance The new fiat token balance of the account. + */ + function _setBalance(address _account, uint256 _balance) internal virtual { + balanceAndBlacklistStates[_account] = _balance; + } + + /** + * + */ + function _isBlacklisted(address _account) + internal + virtual + override + view + returns (bool) + { + return _deprecatedBlacklisted[_account]; + } + + /** + * @dev Helper method to obtain the balance of an account. + * @param _account The address of the account. + * @return The fiat token balance of the account. + */ + function _balanceOf(address _account) + internal + virtual + view + returns (uint256) + { + return balanceAndBlacklistStates[_account]; + } +} + +// contracts/v2/EIP2612.sol +/** + * Copyright 2023 Circle Internet Group, Inc. All rights reserved. + * + + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @title EIP-2612 + * @notice Provide internal implementation for gas-abstracted approvals + */ +abstract contract EIP2612 is AbstractFiatTokenV2, EIP712Domain { + // keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)") + bytes32 + public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9; + + mapping(address => uint256) private _permitNonces; + + /** + * @notice Nonces for permit + * @param owner Token owner's address (Authorizer) + * @return Next nonce + */ + function nonces(address owner) external view returns (uint256) { + return _permitNonces[owner]; + } + + /** + * @notice Verify a signed approval permit and execute if valid + * @param owner Token owner's address (Authorizer) + * @param spender Spender's address + * @param value Amount of allowance + * @param deadline The time at which the signature expires (unix time), or max uint256 value to signal no expiration + * @param v v of the signature + * @param r r of the signature + * @param s s of the signature + */ + function _permit( + address owner, + address spender, + uint256 value, + uint256 deadline, + uint8 v, + bytes32 r, + bytes32 s + ) internal { + _permit(owner, spender, value, deadline, abi.encodePacked(r, s, v)); + } + + /** + * @notice Verify a signed approval permit and execute if valid + * @dev EOA wallet signatures should be packed in the order of r, s, v. + * @param owner Token owner's address (Authorizer) + * @param spender Spender's address + * @param value Amount of allowance + * @param deadline The time at which the signature expires (unix time), or max uint256 value to signal no expiration + * @param signature Signature byte array signed by an EOA wallet or a contract wallet + */ + function _permit( + address owner, + address spender, + uint256 value, + uint256 deadline, + bytes memory signature + ) internal { + require( + deadline == type(uint256).max || deadline >= now, + "FiatTokenV2: permit is expired" + ); + + bytes32 typedDataHash = MessageHashUtils.toTypedDataHash( + _domainSeparator(), + keccak256( + abi.encode( + PERMIT_TYPEHASH, + owner, + spender, + value, + _permitNonces[owner]++, + deadline + ) + ) + ); + require( + SignatureChecker.isValidSignatureNow( + owner, + typedDataHash, + signature + ), + "EIP2612: invalid signature" + ); + + _approve(owner, spender, value); + } +} + +// contracts/v2/EIP3009.sol +/** + * Copyright 2023 Circle Internet Group, Inc. All rights reserved. + * + + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @title EIP-3009 + * @notice Provide internal implementation for gas-abstracted transfers + * @dev Contracts that inherit from this must wrap these with publicly + * accessible functions, optionally adding modifiers where necessary + */ +abstract contract EIP3009 is AbstractFiatTokenV2, EIP712Domain { + // keccak256("TransferWithAuthorization(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)") + bytes32 + public constant TRANSFER_WITH_AUTHORIZATION_TYPEHASH = 0x7c7c6cdb67a18743f49ec6fa9b35f50d52ed05cbed4cc592e13b44501c1a2267; + + // keccak256("ReceiveWithAuthorization(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)") + bytes32 + public constant RECEIVE_WITH_AUTHORIZATION_TYPEHASH = 0xd099cc98ef71107a616c4f0f941f04c322d8e254fe26b3c6668db87aae413de8; + + // keccak256("CancelAuthorization(address authorizer,bytes32 nonce)") + bytes32 + public constant CANCEL_AUTHORIZATION_TYPEHASH = 0x158b0a9edf7a828aad02f63cd515c68ef2f50ba807396f6d12842833a1597429; + + /** + * @dev authorizer address => nonce => bool (true if nonce is used) + */ + mapping(address => mapping(bytes32 => bool)) private _authorizationStates; + + event AuthorizationUsed(address indexed authorizer, bytes32 indexed nonce); + event AuthorizationCanceled( + address indexed authorizer, + bytes32 indexed nonce + ); + + /** + * @notice Returns the state of an authorization + * @dev Nonces are randomly generated 32-byte data unique to the + * authorizer's address + * @param authorizer Authorizer's address + * @param nonce Nonce of the authorization + * @return True if the nonce is used + */ + function authorizationState(address authorizer, bytes32 nonce) + external + view + returns (bool) + { + return _authorizationStates[authorizer][nonce]; + } + + /** + * @notice Execute a transfer with a signed authorization + * @param from Payer's address (Authorizer) + * @param to Payee's address + * @param value Amount to be transferred + * @param validAfter The time after which this is valid (unix time) + * @param validBefore The time before which this is valid (unix time) + * @param nonce Unique nonce + * @param v v of the signature + * @param r r of the signature + * @param s s of the signature + */ + function _transferWithAuthorization( + address from, + address to, + uint256 value, + uint256 validAfter, + uint256 validBefore, + bytes32 nonce, + uint8 v, + bytes32 r, + bytes32 s + ) internal { + _transferWithAuthorization( + from, + to, + value, + validAfter, + validBefore, + nonce, + abi.encodePacked(r, s, v) + ); + } + + /** + * @notice Execute a transfer with a signed authorization + * @dev EOA wallet signatures should be packed in the order of r, s, v. + * @param from Payer's address (Authorizer) + * @param to Payee's address + * @param value Amount to be transferred + * @param validAfter The time after which this is valid (unix time) + * @param validBefore The time before which this is valid (unix time) + * @param nonce Unique nonce + * @param signature Signature byte array produced by an EOA wallet or a contract wallet + */ + function _transferWithAuthorization( + address from, + address to, + uint256 value, + uint256 validAfter, + uint256 validBefore, + bytes32 nonce, + bytes memory signature + ) internal { + _requireValidAuthorization(from, nonce, validAfter, validBefore); + _requireValidSignature( + from, + keccak256( + abi.encode( + TRANSFER_WITH_AUTHORIZATION_TYPEHASH, + from, + to, + value, + validAfter, + validBefore, + nonce + ) + ), + signature + ); + + _markAuthorizationAsUsed(from, nonce); + _transfer(from, to, value); + } + + /** + * @notice Receive a transfer with a signed authorization from the payer + * @dev This has an additional check to ensure that the payee's address + * matches the caller of this function to prevent front-running attacks. + * @param from Payer's address (Authorizer) + * @param to Payee's address + * @param value Amount to be transferred + * @param validAfter The time after which this is valid (unix time) + * @param validBefore The time before which this is valid (unix time) + * @param nonce Unique nonce + * @param v v of the signature + * @param r r of the signature + * @param s s of the signature + */ + function _receiveWithAuthorization( + address from, + address to, + uint256 value, + uint256 validAfter, + uint256 validBefore, + bytes32 nonce, + uint8 v, + bytes32 r, + bytes32 s + ) internal { + _receiveWithAuthorization( + from, + to, + value, + validAfter, + validBefore, + nonce, + abi.encodePacked(r, s, v) + ); + } + + /** + * @notice Receive a transfer with a signed authorization from the payer + * @dev This has an additional check to ensure that the payee's address + * matches the caller of this function to prevent front-running attacks. + * EOA wallet signatures should be packed in the order of r, s, v. + * @param from Payer's address (Authorizer) + * @param to Payee's address + * @param value Amount to be transferred + * @param validAfter The time after which this is valid (unix time) + * @param validBefore The time before which this is valid (unix time) + * @param nonce Unique nonce + * @param signature Signature byte array produced by an EOA wallet or a contract wallet + */ + function _receiveWithAuthorization( + address from, + address to, + uint256 value, + uint256 validAfter, + uint256 validBefore, + bytes32 nonce, + bytes memory signature + ) internal { + require(to == msg.sender, "FiatTokenV2: caller must be the payee"); + _requireValidAuthorization(from, nonce, validAfter, validBefore); + _requireValidSignature( + from, + keccak256( + abi.encode( + RECEIVE_WITH_AUTHORIZATION_TYPEHASH, + from, + to, + value, + validAfter, + validBefore, + nonce + ) + ), + signature + ); + + _markAuthorizationAsUsed(from, nonce); + _transfer(from, to, value); + } + + /** + * @notice Attempt to cancel an authorization + * @param authorizer Authorizer's address + * @param nonce Nonce of the authorization + * @param v v of the signature + * @param r r of the signature + * @param s s of the signature + */ + function _cancelAuthorization( + address authorizer, + bytes32 nonce, + uint8 v, + bytes32 r, + bytes32 s + ) internal { + _cancelAuthorization(authorizer, nonce, abi.encodePacked(r, s, v)); + } + + /** + * @notice Attempt to cancel an authorization + * @dev EOA wallet signatures should be packed in the order of r, s, v. + * @param authorizer Authorizer's address + * @param nonce Nonce of the authorization + * @param signature Signature byte array produced by an EOA wallet or a contract wallet + */ + function _cancelAuthorization( + address authorizer, + bytes32 nonce, + bytes memory signature + ) internal { + _requireUnusedAuthorization(authorizer, nonce); + _requireValidSignature( + authorizer, + keccak256( + abi.encode(CANCEL_AUTHORIZATION_TYPEHASH, authorizer, nonce) + ), + signature + ); + + _authorizationStates[authorizer][nonce] = true; + emit AuthorizationCanceled(authorizer, nonce); + } + + /** + * @notice Validates that signature against input data struct + * @param signer Signer's address + * @param dataHash Hash of encoded data struct + * @param signature Signature byte array produced by an EOA wallet or a contract wallet + */ + function _requireValidSignature( + address signer, + bytes32 dataHash, + bytes memory signature + ) private view { + require( + SignatureChecker.isValidSignatureNow( + signer, + MessageHashUtils.toTypedDataHash(_domainSeparator(), dataHash), + signature + ), + "FiatTokenV2: invalid signature" + ); + } + + /** + * @notice Check that an authorization is unused + * @param authorizer Authorizer's address + * @param nonce Nonce of the authorization + */ + function _requireUnusedAuthorization(address authorizer, bytes32 nonce) + private + view + { + require( + !_authorizationStates[authorizer][nonce], + "FiatTokenV2: authorization is used or canceled" + ); + } + + /** + * @notice Check that authorization is valid + * @param authorizer Authorizer's address + * @param nonce Nonce of the authorization + * @param validAfter The time after which this is valid (unix time) + * @param validBefore The time before which this is valid (unix time) + */ + function _requireValidAuthorization( + address authorizer, + bytes32 nonce, + uint256 validAfter, + uint256 validBefore + ) private view { + require( + now > validAfter, + "FiatTokenV2: authorization is not yet valid" + ); + require(now < validBefore, "FiatTokenV2: authorization is expired"); + _requireUnusedAuthorization(authorizer, nonce); + } + + /** + * @notice Mark an authorization as used + * @param authorizer Authorizer's address + * @param nonce Nonce of the authorization + */ + function _markAuthorizationAsUsed(address authorizer, bytes32 nonce) + private + { + _authorizationStates[authorizer][nonce] = true; + emit AuthorizationUsed(authorizer, nonce); + } +} + +// contracts/v1.1/FiatTokenV1_1.sol +/** + * Copyright 2023 Circle Internet Group, Inc. All rights reserved. + * + + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @title FiatTokenV1_1 + * @dev ERC20 Token backed by fiat reserves + */ +contract FiatTokenV1_1 is FiatTokenV1, Rescuable { + +} + +// contracts/v2/FiatTokenV2.sol +/** + * Copyright 2023 Circle Internet Group, Inc. All rights reserved. + * + + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @title FiatToken V2 + * @notice ERC20 Token backed by fiat reserves, version 2 + */ +contract FiatTokenV2 is FiatTokenV1_1, EIP3009, EIP2612 { + uint8 internal _initializedVersion; + + /** + * @notice Initialize v2 + * @param newName New token name + */ + function initializeV2(string calldata newName) external { + // solhint-disable-next-line reason-string + require(initialized && _initializedVersion == 0); + name = newName; + _DEPRECATED_CACHED_DOMAIN_SEPARATOR = EIP712.makeDomainSeparator( + newName, + "2" + ); + _initializedVersion = 1; + } + + /** + * @notice Increase the allowance by a given increment + * @param spender Spender's address + * @param increment Amount of increase in allowance + * @return True if successful + */ + function increaseAllowance(address spender, uint256 increment) + external + virtual + whenNotPaused + notBlacklisted(msg.sender) + notBlacklisted(spender) + returns (bool) + { + _increaseAllowance(msg.sender, spender, increment); + return true; + } + + /** + * @notice Decrease the allowance by a given decrement + * @param spender Spender's address + * @param decrement Amount of decrease in allowance + * @return True if successful + */ + function decreaseAllowance(address spender, uint256 decrement) + external + virtual + whenNotPaused + notBlacklisted(msg.sender) + notBlacklisted(spender) + returns (bool) + { + _decreaseAllowance(msg.sender, spender, decrement); + return true; + } + + /** + * @notice Execute a transfer with a signed authorization + * @param from Payer's address (Authorizer) + * @param to Payee's address + * @param value Amount to be transferred + * @param validAfter The time after which this is valid (unix time) + * @param validBefore The time before which this is valid (unix time) + * @param nonce Unique nonce + * @param v v of the signature + * @param r r of the signature + * @param s s of the signature + */ + function transferWithAuthorization( + address from, + address to, + uint256 value, + uint256 validAfter, + uint256 validBefore, + bytes32 nonce, + uint8 v, + bytes32 r, + bytes32 s + ) external whenNotPaused notBlacklisted(from) notBlacklisted(to) { + _transferWithAuthorization( + from, + to, + value, + validAfter, + validBefore, + nonce, + v, + r, + s + ); + } + + /** + * @notice Receive a transfer with a signed authorization from the payer + * @dev This has an additional check to ensure that the payee's address + * matches the caller of this function to prevent front-running attacks. + * @param from Payer's address (Authorizer) + * @param to Payee's address + * @param value Amount to be transferred + * @param validAfter The time after which this is valid (unix time) + * @param validBefore The time before which this is valid (unix time) + * @param nonce Unique nonce + * @param v v of the signature + * @param r r of the signature + * @param s s of the signature + */ + function receiveWithAuthorization( + address from, + address to, + uint256 value, + uint256 validAfter, + uint256 validBefore, + bytes32 nonce, + uint8 v, + bytes32 r, + bytes32 s + ) external whenNotPaused notBlacklisted(from) notBlacklisted(to) { + _receiveWithAuthorization( + from, + to, + value, + validAfter, + validBefore, + nonce, + v, + r, + s + ); + } + + /** + * @notice Attempt to cancel an authorization + * @dev Works only if the authorization is not yet used. + * @param authorizer Authorizer's address + * @param nonce Nonce of the authorization + * @param v v of the signature + * @param r r of the signature + * @param s s of the signature + */ + function cancelAuthorization( + address authorizer, + bytes32 nonce, + uint8 v, + bytes32 r, + bytes32 s + ) external whenNotPaused { + _cancelAuthorization(authorizer, nonce, v, r, s); + } + + /** + * @notice Update allowance with a signed permit + * @param owner Token owner's address (Authorizer) + * @param spender Spender's address + * @param value Amount of allowance + * @param deadline The time at which the signature expires (unix time), or max uint256 value to signal no expiration + * @param v v of the signature + * @param r r of the signature + * @param s s of the signature + */ + function permit( + address owner, + address spender, + uint256 value, + uint256 deadline, + uint8 v, + bytes32 r, + bytes32 s + ) + external + virtual + whenNotPaused + notBlacklisted(owner) + notBlacklisted(spender) + { + _permit(owner, spender, value, deadline, v, r, s); + } + + /** + * @dev Internal function to increase the allowance by a given increment + * @param owner Token owner's address + * @param spender Spender's address + * @param increment Amount of increase + */ + function _increaseAllowance( + address owner, + address spender, + uint256 increment + ) internal override { + _approve(owner, spender, allowed[owner][spender].add(increment)); + } + + /** + * @dev Internal function to decrease the allowance by a given decrement + * @param owner Token owner's address + * @param spender Spender's address + * @param decrement Amount of decrease + */ + function _decreaseAllowance( + address owner, + address spender, + uint256 decrement + ) internal override { + _approve( + owner, + spender, + allowed[owner][spender].sub( + decrement, + "ERC20: decreased allowance below zero" + ) + ); + } +} + +// contracts/v2/FiatTokenV2_1.sol +/** + * Copyright 2023 Circle Internet Group, Inc. All rights reserved. + * + + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// solhint-disable func-name-mixedcase + +/** + * @title FiatToken V2.1 + * @notice ERC20 Token backed by fiat reserves, version 2.1 + */ +contract FiatTokenV2_1 is FiatTokenV2 { + /** + * @notice Initialize v2.1 + * @param lostAndFound The address to which the locked funds are sent + */ + function initializeV2_1(address lostAndFound) external { + // solhint-disable-next-line reason-string + require(_initializedVersion == 1); + + uint256 lockedAmount = _balanceOf(address(this)); + if (lockedAmount > 0) { + _transfer(address(this), lostAndFound, lockedAmount); + } + _blacklist(address(this)); + + _initializedVersion = 2; + } + + /** + * @notice Version string for the EIP712 domain separator + * @return Version string + */ + function version() external pure returns (string memory) { + return "2"; + } +} + +// contracts/v2/FiatTokenV2_2.sol +/** + * Copyright 2023 Circle Internet Group, Inc. All rights reserved. + * + + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + // solhint-disable-line no-unused-import + // solhint-disable-line no-unused-import + // solhint-disable-line no-unused-import + // solhint-disable-line no-unused-import + +// solhint-disable func-name-mixedcase + +/** + * @title FiatToken V2.2 + * @notice ERC20 Token backed by fiat reserves, version 2.2 + */ +contract FiatTokenV2_2 is FiatTokenV2_1 { + /** + * @notice Initialize v2.2 + * @param accountsToBlacklist A list of accounts to migrate from the old blacklist + * @param newSymbol New token symbol + * data structure to the new blacklist data structure. + */ + function initializeV2_2( + address[] calldata accountsToBlacklist, + string calldata newSymbol + ) external { + // solhint-disable-next-line reason-string + require(_initializedVersion == 2); + + // Update fiat token symbol + symbol = newSymbol; + + // Add previously blacklisted accounts to the new blacklist data structure + // and remove them from the old blacklist data structure. + for (uint256 i = 0; i < accountsToBlacklist.length; i++) { + require( + _deprecatedBlacklisted[accountsToBlacklist[i]], + "FiatTokenV2_2: Blacklisting previously unblacklisted account!" + ); + _blacklist(accountsToBlacklist[i]); + delete _deprecatedBlacklisted[accountsToBlacklist[i]]; + } + _blacklist(address(this)); + delete _deprecatedBlacklisted[address(this)]; + + _initializedVersion = 3; + } + + /** + * @dev Internal function to get the current chain id. + * @return The current chain id. + */ + function _chainId() internal virtual view returns (uint256) { + uint256 chainId; + assembly { + chainId := chainid() + } + return chainId; + } + + /** + * + */ + function _domainSeparator() internal override view returns (bytes32) { + return EIP712.makeDomainSeparator(name, "2", _chainId()); + } + + /** + * @notice Update allowance with a signed permit + * @dev EOA wallet signatures should be packed in the order of r, s, v. + * @param owner Token owner's address (Authorizer) + * @param spender Spender's address + * @param value Amount of allowance + * @param deadline The time at which the signature expires (unix time), or max uint256 value to signal no expiration + * @param signature Signature bytes signed by an EOA wallet or a contract wallet + */ + function permit( + address owner, + address spender, + uint256 value, + uint256 deadline, + bytes memory signature + ) external whenNotPaused { + _permit(owner, spender, value, deadline, signature); + } + + /** + * @notice Execute a transfer with a signed authorization + * @dev EOA wallet signatures should be packed in the order of r, s, v. + * @param from Payer's address (Authorizer) + * @param to Payee's address + * @param value Amount to be transferred + * @param validAfter The time after which this is valid (unix time) + * @param validBefore The time before which this is valid (unix time) + * @param nonce Unique nonce + * @param signature Signature bytes signed by an EOA wallet or a contract wallet + */ + function transferWithAuthorization( + address from, + address to, + uint256 value, + uint256 validAfter, + uint256 validBefore, + bytes32 nonce, + bytes memory signature + ) external whenNotPaused notBlacklisted(from) notBlacklisted(to) { + _transferWithAuthorization( + from, + to, + value, + validAfter, + validBefore, + nonce, + signature + ); + } + + /** + * @notice Receive a transfer with a signed authorization from the payer + * @dev This has an additional check to ensure that the payee's address + * matches the caller of this function to prevent front-running attacks. + * EOA wallet signatures should be packed in the order of r, s, v. + * @param from Payer's address (Authorizer) + * @param to Payee's address + * @param value Amount to be transferred + * @param validAfter The time after which this is valid (unix time) + * @param validBefore The time before which this is valid (unix time) + * @param nonce Unique nonce + * @param signature Signature bytes signed by an EOA wallet or a contract wallet + */ + function receiveWithAuthorization( + address from, + address to, + uint256 value, + uint256 validAfter, + uint256 validBefore, + bytes32 nonce, + bytes memory signature + ) external whenNotPaused notBlacklisted(from) notBlacklisted(to) { + _receiveWithAuthorization( + from, + to, + value, + validAfter, + validBefore, + nonce, + signature + ); + } + + /** + * @notice Attempt to cancel an authorization + * @dev Works only if the authorization is not yet used. + * EOA wallet signatures should be packed in the order of r, s, v. + * @param authorizer Authorizer's address + * @param nonce Nonce of the authorization + * @param signature Signature bytes signed by an EOA wallet or a contract wallet + */ + function cancelAuthorization( + address authorizer, + bytes32 nonce, + bytes memory signature + ) external whenNotPaused { + _cancelAuthorization(authorizer, nonce, signature); + } + + /** + * @dev Helper method that sets the blacklist state of an account on balanceAndBlacklistStates. + * If _shouldBlacklist is true, we apply a (1 << 255) bitmask with an OR operation on the + * account's balanceAndBlacklistState. This flips the high bit for the account to 1, + * indicating that the account is blacklisted. + * + * If _shouldBlacklist if false, we reset the account's balanceAndBlacklistStates to their + * balances. This clears the high bit for the account, indicating that the account is unblacklisted. + * @param _account The address of the account. + * @param _shouldBlacklist True if the account should be blacklisted, false if the account should be unblacklisted. + */ + function _setBlacklistState(address _account, bool _shouldBlacklist) + internal + override + { + balanceAndBlacklistStates[_account] = _shouldBlacklist + ? balanceAndBlacklistStates[_account] | (1 << 255) + : _balanceOf(_account); + } + + /** + * @dev Helper method that sets the balance of an account on balanceAndBlacklistStates. + * Since balances are stored in the last 255 bits of the balanceAndBlacklistStates value, + * we need to ensure that the updated balance does not exceed (2^255 - 1). + * Since blacklisted accounts' balances cannot be updated, the method will also + * revert if the account is blacklisted + * @param _account The address of the account. + * @param _balance The new fiat token balance of the account (max: (2^255 - 1)). + */ + function _setBalance(address _account, uint256 _balance) internal override { + require( + _balance <= ((1 << 255) - 1), + "FiatTokenV2_2: Balance exceeds (2^255 - 1)" + ); + require( + !_isBlacklisted(_account), + "FiatTokenV2_2: Account is blacklisted" + ); + + balanceAndBlacklistStates[_account] = _balance; + } + + /** + * + */ + function _isBlacklisted(address _account) + internal + override + view + returns (bool) + { + return balanceAndBlacklistStates[_account] >> 255 == 1; + } + + /** + * @dev Helper method to obtain the balance of an account. Since balances + * are stored in the last 255 bits of the balanceAndBlacklistStates value, + * we apply a ((1 << 255) - 1) bit bitmask with an AND operation on the + * balanceAndBlacklistState to obtain the balance. + * @param _account The address of the account. + * @return The fiat token balance of the account. + */ + function _balanceOf(address _account) + internal + override + view + returns (uint256) + { + return balanceAndBlacklistStates[_account] & ((1 << 255) - 1); + } + + /** + * + */ + function approve(address spender, uint256 value) + external + override + whenNotPaused + returns (bool) + { + _approve(msg.sender, spender, value); + return true; + } + + /** + * + */ + function permit( + address owner, + address spender, + uint256 value, + uint256 deadline, + uint8 v, + bytes32 r, + bytes32 s + ) external override whenNotPaused { + _permit(owner, spender, value, deadline, v, r, s); + } + + /** + * + */ + function increaseAllowance(address spender, uint256 increment) + external + override + whenNotPaused + returns (bool) + { + _increaseAllowance(msg.sender, spender, increment); + return true; + } + + /** + * + */ + function decreaseAllowance(address spender, uint256 decrement) + external + override + whenNotPaused + returns (bool) + { + _decreaseAllowance(msg.sender, spender, decrement); + return true; + } +} diff --git a/contracts/contracts/libraries/usdc/MigrationUSDC.sol b/contracts/contracts/libraries/usdc/MigrationUSDC.sol new file mode 100644 index 000000000..ffef27aa9 --- /dev/null +++ b/contracts/contracts/libraries/usdc/MigrationUSDC.sol @@ -0,0 +1,110 @@ +// SPDX-License-Identifier: MIT + +pragma solidity =0.8.24; + +import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; +import {PausableUpgradeable} from "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol"; +import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol"; +import {IERC20Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol"; +import {SafeERC20Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol"; + +contract MigrationUSDC is OwnableUpgradeable, PausableUpgradeable, ReentrancyGuardUpgradeable { + using SafeERC20Upgradeable for IERC20Upgradeable; + + error ErrZeroAddress(); + + /// @dev Thrown the token balance is zero. + error ErrorTokenBalanceZero(); + + event Migrate(address indexed user, uint256 amount); + event Transfer(address indexed token, address indexed to, uint256 amount); + event UpdateRecipient(address indexed oldRecipient, address indexed newRecipient); + + /// @notice The address of old USDC address. + address public immutable OLD_USDC; + + /// @notice The address of new USDC address. + address public immutable NEW_USDC; + + /// @notice Wallet that will receive the tokens on L2. + address public recipient; + + /*************** + * Constructor * + ***************/ + /// @notice Constructor for `MigrationUSDC` implementation contract. + /// + /// @param _oldUSDC The address of old USDC in L2. + /// @param _newUSDC The address of new USDC in L2. + constructor(address _oldUSDC, address _newUSDC) { + _disableInitializers(); + + OLD_USDC = _oldUSDC; + NEW_USDC = _newUSDC; + } + + // initialize contract status + function initialize(address _recipient) external initializer { + if (_recipient == address(0)) { + revert ErrZeroAddress(); + } + recipient = _recipient; + + __Ownable_init(); + __Pausable_init(); + __ReentrancyGuard_init(); + + emit UpdateRecipient(address(0), recipient); + } + + // Transfer all old USDC to this contract and then transfer new USDC token to msg sender. + function migrate() external nonReentrant whenNotPaused { + // Get old USDC balance. + uint256 balance = IERC20Upgradeable(OLD_USDC).balanceOf(_msgSender()); + if (balance == 0) { + revert ErrorTokenBalanceZero(); + } + // Transfer token into this contract. + IERC20Upgradeable(OLD_USDC).safeTransferFrom(_msgSender(), address(this), balance); + // Transfer new USDC token to msg sender. + IERC20Upgradeable(NEW_USDC).transfer(_msgSender(), balance); + emit Migrate(_msgSender(), balance); + } + + // Transfer token to other address. + function transferToken(address _token, uint256 _amount) external onlyOwner { + if (recipient == address(0)) { + revert ErrZeroAddress(); + } + uint256 balance = IERC20Upgradeable(_token).balanceOf(address(this)); + if (balance == 0) { + revert ErrorTokenBalanceZero(); + } + // transfer all token + if (balance < _amount) { + _amount = balance; + } + // Transfer token. + IERC20Upgradeable(_token).transfer(recipient, _amount); + emit Transfer(_token, recipient, _amount); + } + + // Update the address of recipient. + function updateRecipient(address _newRecipient) external onlyOwner { + address _oldRecipient = recipient; + recipient = _newRecipient; + + emit UpdateRecipient(_oldRecipient, _newRecipient); + } + + // Change pause status + function setPause(bool status) external onlyOwner { + if (status) { + _requireNotPaused(); + _pause(); + } else { + _requirePaused(); + _unpause(); + } + } +} diff --git a/contracts/contracts/libraries/usdc/SignatureChecker.sol.flatten b/contracts/contracts/libraries/usdc/SignatureChecker.sol.flatten new file mode 100644 index 000000000..5f3ef0554 --- /dev/null +++ b/contracts/contracts/libraries/usdc/SignatureChecker.sol.flatten @@ -0,0 +1,219 @@ +// SPDX-License-Identifier: Apache-2.0 +pragma solidity =0.6.12; + +// contracts/interface/IERC1271.sol +/** + * Copyright 2023 Circle Internet Group, Inc. All rights reserved. + * + + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @dev Interface of the ERC1271 standard signature validation method for + * contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271]. + */ +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 the provided data hash + * @return magicValue bytes4 magic value 0x1626ba7e when function passes + */ + function isValidSignature(bytes32 hash, bytes memory signature) + external + view + returns (bytes4 magicValue); +} + +// contracts/util/ECRecover.sol +/** + * Copyright 2023 Circle Internet Group, Inc. All rights reserved. + * + + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @title ECRecover + * @notice A library that provides a safe ECDSA recovery function + */ +library ECRecover { + /** + * @notice Recover signer's address from a signed message + * @dev Adapted from: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/65e4ffde586ec89af3b7e9140bdc9235d1254853/contracts/cryptography/ECDSA.sol + * Modifications: Accept v, r, and s as separate arguments + * @param digest Keccak-256 hash digest of the signed message + * @param v v of the signature + * @param r r of the signature + * @param s s of the signature + * @return Signer address + */ + function recover( + bytes32 digest, + uint8 v, + bytes32 r, + bytes32 s + ) internal pure returns (address) { + // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature + // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines + // the valid range for s in (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): v ∈ {27, 28}. Most + // signatures from current libraries generate a unique signature with an s-value in the lower half order. + // + // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value + // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or + // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept + // these malleable signatures as well. + if ( + uint256(s) > + 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0 + ) { + revert("ECRecover: invalid signature 's' value"); + } + + if (v != 27 && v != 28) { + revert("ECRecover: invalid signature 'v' value"); + } + + // If the signature is valid (and not malleable), return the signer address + address signer = ecrecover(digest, v, r, s); + require(signer != address(0), "ECRecover: invalid signature"); + + return signer; + } + + /** + * @notice Recover signer's address from a signed message + * @dev Adapted from: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/0053ee040a7ff1dbc39691c9e67a69f564930a88/contracts/utils/cryptography/ECDSA.sol + * @param digest Keccak-256 hash digest of the signed message + * @param signature Signature byte array associated with hash + * @return Signer address + */ + function recover(bytes32 digest, bytes memory signature) + internal + pure + returns (address) + { + require(signature.length == 65, "ECRecover: invalid signature length"); + + bytes32 r; + bytes32 s; + uint8 v; + + // ecrecover takes the signature parameters, and the only way to get them + // currently is to use assembly. + /// @solidity memory-safe-assembly + assembly { + r := mload(add(signature, 0x20)) + s := mload(add(signature, 0x40)) + v := byte(0, mload(add(signature, 0x60))) + } + return recover(digest, v, r, s); + } +} + +// contracts/util/SignatureChecker.sol +/** + * Copyright 2023 Circle Internet Group, Inc. All rights reserved. + * + + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @dev Signature verification helper that can be used instead of `ECRecover.recover` to seamlessly support both ECDSA + * signatures from externally owned accounts (EOAs) as well as ERC1271 signatures from smart contract wallets. + * + * Adapted from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/21bb89ef5bfc789b9333eb05e3ba2b7b284ac77c/contracts/utils/cryptography/SignatureChecker.sol + */ +library SignatureChecker { + /** + * @dev Checks if a signature is valid for a given signer and data hash. If the signer is a smart contract, the + * signature is validated against that smart contract using ERC1271, otherwise it's validated using `ECRecover.recover`. + * @param signer Address of the claimed signer + * @param digest Keccak-256 hash digest of the signed message + * @param signature Signature byte array associated with hash + */ + function isValidSignatureNow( + address signer, + bytes32 digest, + bytes memory signature + ) external view returns (bool) { + if (!isContract(signer)) { + return ECRecover.recover(digest, signature) == signer; + } + return isValidERC1271SignatureNow(signer, digest, signature); + } + + /** + * @dev Checks if a signature is valid for a given signer and data hash. The signature is validated + * against the signer smart contract using ERC1271. + * @param signer Address of the claimed signer + * @param digest Keccak-256 hash digest of the signed message + * @param signature Signature byte array associated with hash + * + * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus + * change through time. It could return true at block N and false at block N+1 (or the opposite). + */ + function isValidERC1271SignatureNow( + address signer, + bytes32 digest, + bytes memory signature + ) internal view returns (bool) { + (bool success, bytes memory result) = signer.staticcall( + abi.encodeWithSelector( + IERC1271.isValidSignature.selector, + digest, + signature + ) + ); + return (success && + result.length >= 32 && + abi.decode(result, (bytes32)) == + bytes32(IERC1271.isValidSignature.selector)); + } + + /** + * @dev Checks if the input address is a smart contract. + */ + function isContract(address addr) internal view returns (bool) { + uint256 size; + assembly { + size := extcodesize(addr) + } + return size > 0; + } +} diff --git a/contracts/tasks/token_deploy.ts b/contracts/tasks/token_deploy.ts index bd7a10ef3..b942b243b 100644 --- a/contracts/tasks/token_deploy.ts +++ b/contracts/tasks/token_deploy.ts @@ -253,11 +253,11 @@ task("init-l1-lidogateway") const gateway = await GatewayFactory.attach(taskArgs.l1lidogateway) console.log(`gateway at ${gateway.address}`) - let res = await gateway.initialize(taskArgs.counterpart,taskArgs.router,taskArgs.messenger) + let res = await gateway.initialize(taskArgs.counterpart, taskArgs.router, taskArgs.messenger) let rec = await res.wait() console.log(`initialize ${rec.status == 1}, txHash: ${rec.transactionHash}`) - res = await gateway.initializeV2(taskArgs.opter,taskArgs.opter,taskArgs.opter,taskArgs.opter) + res = await gateway.initializeV2(taskArgs.opter, taskArgs.opter, taskArgs.opter, taskArgs.opter) rec = await res.wait() console.log(`initializeV2 ${rec.status == 1}, txHash: ${rec.transactionHash}`) @@ -268,14 +268,14 @@ task("init-l1-lidogateway") let withdrawalEnabled = await gateway.isWithdrawalsEnabled() console.log(`counterpart ${counterpart}, router ${router}, messenger ${messenger}, depositEnabled ${depositEnabled}, withdrawalEnabled ${withdrawalEnabled}`) - const DEPOSITS_ENABLER_ROLE =await gateway.DEPOSITS_ENABLER_ROLE() - const DEPOSITS_DISABLER_ROLE =await gateway.DEPOSITS_DISABLER_ROLE() - const WITHDRAWALS_ENABLER_ROLE =await gateway.WITHDRAWALS_ENABLER_ROLE() - const WITHDRAWALS_DISABLER_ROLE =await gateway.WITHDRAWALS_DISABLER_ROLE() - const depositE = await gateway.hasRole(DEPOSITS_ENABLER_ROLE,taskArgs.opter) - const depositD = await gateway.hasRole(DEPOSITS_DISABLER_ROLE,taskArgs.opter) - const withdrawE = await gateway.hasRole(WITHDRAWALS_ENABLER_ROLE,taskArgs.opter) - const withdrawD = await gateway.hasRole(WITHDRAWALS_DISABLER_ROLE,taskArgs.opter) + const DEPOSITS_ENABLER_ROLE = await gateway.DEPOSITS_ENABLER_ROLE() + const DEPOSITS_DISABLER_ROLE = await gateway.DEPOSITS_DISABLER_ROLE() + const WITHDRAWALS_ENABLER_ROLE = await gateway.WITHDRAWALS_ENABLER_ROLE() + const WITHDRAWALS_DISABLER_ROLE = await gateway.WITHDRAWALS_DISABLER_ROLE() + const depositE = await gateway.hasRole(DEPOSITS_ENABLER_ROLE, taskArgs.opter) + const depositD = await gateway.hasRole(DEPOSITS_DISABLER_ROLE, taskArgs.opter) + const withdrawE = await gateway.hasRole(WITHDRAWALS_ENABLER_ROLE, taskArgs.opter) + const withdrawD = await gateway.hasRole(WITHDRAWALS_DISABLER_ROLE, taskArgs.opter) console.log(`Role: depositE ${depositE}, depositD ${depositD}, withdrawE ${withdrawE}, withdrawD ${withdrawD}`) }) @@ -301,11 +301,11 @@ task("init-l2-lidogateway") const gateway = await GatewayFactory.attach(taskArgs.l2lidogateway) console.log(`gateway at ${gateway.address}`) - let res = await gateway.initialize(taskArgs.counterpart,taskArgs.router,taskArgs.messenger) + let res = await gateway.initialize(taskArgs.counterpart, taskArgs.router, taskArgs.messenger) let rec = await res.wait() console.log(`initialize ${rec.status == 1}, txHash: ${rec.transactionHash}`) - res = await gateway.initializeV2(taskArgs.opter,taskArgs.opter,taskArgs.opter,taskArgs.opter) + res = await gateway.initializeV2(taskArgs.opter, taskArgs.opter, taskArgs.opter, taskArgs.opter) rec = await res.wait() console.log(`initializeV2 ${rec.status == 1}, txHash: ${rec.transactionHash}`) @@ -316,14 +316,14 @@ task("init-l2-lidogateway") let withdrawalEnabled = await gateway.isWithdrawalsEnabled() console.log(`counterpart ${counterpart}, router ${router}, messenger ${messenger}, depositEnabled ${depositEnabled}, withdrawalEnabled ${withdrawalEnabled}`) - const DEPOSITS_ENABLER_ROLE =await gateway.DEPOSITS_ENABLER_ROLE() - const DEPOSITS_DISABLER_ROLE =await gateway.DEPOSITS_DISABLER_ROLE() - const WITHDRAWALS_ENABLER_ROLE =await gateway.WITHDRAWALS_ENABLER_ROLE() - const WITHDRAWALS_DISABLER_ROLE =await gateway.WITHDRAWALS_DISABLER_ROLE() - const depositE = await gateway.hasRole(DEPOSITS_ENABLER_ROLE,taskArgs.opter) - const depositD = await gateway.hasRole(DEPOSITS_DISABLER_ROLE,taskArgs.opter) - const withdrawE = await gateway.hasRole(WITHDRAWALS_ENABLER_ROLE,taskArgs.opter) - const withdrawD = await gateway.hasRole(WITHDRAWALS_DISABLER_ROLE,taskArgs.opter) + const DEPOSITS_ENABLER_ROLE = await gateway.DEPOSITS_ENABLER_ROLE() + const DEPOSITS_DISABLER_ROLE = await gateway.DEPOSITS_DISABLER_ROLE() + const WITHDRAWALS_ENABLER_ROLE = await gateway.WITHDRAWALS_ENABLER_ROLE() + const WITHDRAWALS_DISABLER_ROLE = await gateway.WITHDRAWALS_DISABLER_ROLE() + const depositE = await gateway.hasRole(DEPOSITS_ENABLER_ROLE, taskArgs.opter) + const depositD = await gateway.hasRole(DEPOSITS_DISABLER_ROLE, taskArgs.opter) + const withdrawE = await gateway.hasRole(WITHDRAWALS_ENABLER_ROLE, taskArgs.opter) + const withdrawD = await gateway.hasRole(WITHDRAWALS_DISABLER_ROLE, taskArgs.opter) console.log(`Role: depositE ${depositE}, depositD ${depositD}, withdrawE ${withdrawE}, withdrawD ${withdrawD}`) }) @@ -336,48 +336,49 @@ task("upgrade-l1-usdcgateway") .addParam("router") .addParam("messenger") .setAction(async (taskArgs, hre) => { - // params check - if (!ethers.utils.isAddress(taskArgs.proxyadmin) || - !ethers.utils.isAddress(taskArgs.l1usdcgatewayproxy) || - !ethers.utils.isAddress(taskArgs.l1token) || - !ethers.utils.isAddress(taskArgs.l2token) || - !ethers.utils.isAddress(taskArgs.counterpart) || - !ethers.utils.isAddress(taskArgs.router) || - !ethers.utils.isAddress(taskArgs.messenger) - ) { - console.error(`address params check failed`) - return - } - // deploy gateway impl - const GatewayFactory = await hre.ethers.getContractFactory("L1USDCGateway") - const gateway = await GatewayFactory.deploy(taskArgs.l1token, taskArgs.l2token) - await gateway.deployed() - console.log(`gateway impl deployed at ${gateway.address}`) - - // upgrade proxy with initialize - const ProxyAdminFactory = await hre.ethers.getContractFactory("ProxyAdmin") - const proxyAdmin = await ProxyAdminFactory.attach(taskArgs.proxyadmin) - console.log(`proxy admin at ${proxyAdmin.address}`) - - let res = await proxyAdmin.upgradeAndCall( - taskArgs.l1usdcgatewayproxy, - gateway.address, - GatewayFactory.interface.encodeFunctionData("initialize", [ - taskArgs.counterpart, - taskArgs.router, - taskArgs.messenger - ] - ) - ) - let rec =await res.wait() - console.log(`upgrade gateway ${rec.status == 1}`) - - const gatewayProxy = GatewayFactory.attach(taskArgs.l1usdcgatewayproxy) - const counterpart = await gatewayProxy.counterpart() - const router = await gatewayProxy.router() - const l1USDC = await gatewayProxy.l1USDC() - const l2USDC = await gatewayProxy.l2USDC() - console.log(`gatewayProxy ${gatewayProxy.address}, counterpart ${counterpart}, router ${router}, l1USDC ${l1USDC}, l2USDC ${l2USDC}`) + // params check + if (!ethers.utils.isAddress(taskArgs.proxyadmin) || + !ethers.utils.isAddress(taskArgs.l1usdcgatewayproxy) || + !ethers.utils.isAddress(taskArgs.l1token) || + !ethers.utils.isAddress(taskArgs.l2token) || + !ethers.utils.isAddress(taskArgs.counterpart) || + !ethers.utils.isAddress(taskArgs.router) || + !ethers.utils.isAddress(taskArgs.messenger) + ) { + console.error(`address params check failed`) + return + } + // deploy gateway impl + const GatewayFactory = await hre.ethers.getContractFactory("L1USDCGateway") + const gateway = await GatewayFactory.deploy(taskArgs.l1token, taskArgs.l2token) + await gateway.deployed() + console.log(`gateway impl deployed at ${gateway.address}`) + + // upgrade proxy with initialize + const ProxyAdminFactory = await hre.ethers.getContractFactory("ProxyAdmin") + const proxyAdmin = await ProxyAdminFactory.attach(taskArgs.proxyadmin) + console.log(`proxy admin at ${proxyAdmin.address}`) + + let res = await proxyAdmin.upgrade( + taskArgs.l1usdcgatewayproxy, + gateway.address + ) + let rec = await res.wait() + console.log(`upgrade gateway ${rec.status == 1}`) + + + const gatewayProxy = GatewayFactory.attach(taskArgs.l1usdcgatewayproxy) + res = await gatewayProxy.initialize(taskArgs.counterpart, taskArgs.router, taskArgs.messenger) + rec = await res.wait() + console.log(`init gateway ${rec.status == 1}`) + + const owner = await gatewayProxy.owner() + const counterpart = await gatewayProxy.counterpart() + const router = await gatewayProxy.router() + const messenger = await gatewayProxy.messenger() + const l1USDC = await gatewayProxy.l1USDC() + const l2USDC = await gatewayProxy.l2USDC() + console.log(`owner ${owner}, gatewayProxy ${gatewayProxy.address}, counterpart ${counterpart}, router ${router}, messenger ${messenger}, l1USDC ${l1USDC}, l2USDC ${l2USDC}`) }) task("upgrade-l2-usdcgateway") @@ -389,48 +390,45 @@ task("upgrade-l2-usdcgateway") .addParam("router") .addParam("messenger") .setAction(async (taskArgs, hre) => { - // params check - if (!ethers.utils.isAddress(taskArgs.proxyadmin) || - !ethers.utils.isAddress(taskArgs.l2usdcgatewayproxy) || - !ethers.utils.isAddress(taskArgs.l1token) || - !ethers.utils.isAddress(taskArgs.l2token) || - !ethers.utils.isAddress(taskArgs.counterpart) || - !ethers.utils.isAddress(taskArgs.router) || - !ethers.utils.isAddress(taskArgs.messenger) - ) { - console.error(`address params check failed`) - return - } - // deploy gateway impl - const GatewayFactory = await hre.ethers.getContractFactory("L2USDCGateway") - const gateway = await GatewayFactory.deploy(taskArgs.l1token, taskArgs.l2token) - await gateway.deployed() - console.log(`gateway impl deployed at ${gateway.address}`) - - // upgrade proxy with initialize - const ProxyAdminFactory = await hre.ethers.getContractFactory("ProxyAdmin") - const proxyAdmin = await ProxyAdminFactory.attach(taskArgs.proxyadmin) - console.log(`proxy admin at ${proxyAdmin.address}`) - - let res = await proxyAdmin.upgradeAndCall( - taskArgs.l2usdcgatewayproxy, - gateway.address, - GatewayFactory.interface.encodeFunctionData("initialize", [ - taskArgs.counterpart, - taskArgs.router, - taskArgs.messenger - ] - ) - ) - let rec =await res.wait() - console.log(`upgrade gateway ${rec.status == 1}`) - - const gatewayProxy = GatewayFactory.attach(taskArgs.l2usdcgatewayproxy) - const counterpart = await gatewayProxy.counterpart() - const router = await gatewayProxy.router() - const l1USDC = await gatewayProxy.l1USDC() - const l2USDC = await gatewayProxy.l2USDC() - console.log(`gatewayProxy ${gatewayProxy.address}, counterpart ${counterpart}, router ${router}, l1USDC ${l1USDC}, l2USDC ${l2USDC}`) + // params check + if (!ethers.utils.isAddress(taskArgs.proxyadmin) || + !ethers.utils.isAddress(taskArgs.l2usdcgatewayproxy) || + !ethers.utils.isAddress(taskArgs.l1token) || + !ethers.utils.isAddress(taskArgs.l2token) || + !ethers.utils.isAddress(taskArgs.counterpart) || + !ethers.utils.isAddress(taskArgs.router) || + !ethers.utils.isAddress(taskArgs.messenger) + ) { + console.error(`address params check failed`) + return + } + // deploy gateway impl + const GatewayFactory = await hre.ethers.getContractFactory("L2USDCGateway") + const gateway = await GatewayFactory.deploy(taskArgs.l1token, taskArgs.l2token) + await gateway.deployed() + console.log(`gateway impl deployed at ${gateway.address}`) + + // upgrade proxy with initialize + const ProxyAdminFactory = await hre.ethers.getContractFactory("ProxyAdmin") + const proxyAdmin = await ProxyAdminFactory.attach(taskArgs.proxyadmin) + console.log(`proxy admin at ${proxyAdmin.address}`) + + let res = await proxyAdmin.upgrade( + taskArgs.l2usdcgatewayproxy, + gateway.address + ) + let rec = await res.wait() + console.log(`upgrade gateway ${rec.status == 1}`) + + const gatewayProxy = GatewayFactory.attach(taskArgs.l2usdcgatewayproxy) + res = await gatewayProxy.initialize(taskArgs.counterpart, taskArgs.router, taskArgs.messenger) + rec = await res.wait() + console.log(`init gateway ${rec.status == 1}`) + const counterpart = await gatewayProxy.counterpart() + const router = await gatewayProxy.router() + const l1USDC = await gatewayProxy.l1USDC() + const l2USDC = await gatewayProxy.l2USDC() + console.log(`gatewayProxy ${gatewayProxy.address}, counterpart ${counterpart}, router ${router}, l1USDC ${l1USDC}, l2USDC ${l2USDC}`) }) task("upgrade-l2-usdc-v2") @@ -454,7 +452,7 @@ task("upgrade-l2-usdc-v2") let res = await proxyAdmin.upgradeAndCall( taskArgs.l2usdcproxy, taskArgs.newimpl, - new ethers.utils.Interface(V2_1ABI).encodeFunctionData("initializeV2",[ + new ethers.utils.Interface(V2_1ABI).encodeFunctionData("initializeV2", [ "USD Coin" ]) ) @@ -491,7 +489,7 @@ task("upgrade-l2-usdc-v2-1") let rec = await res.wait() console.log(`upgrade usdc v2 ${rec.status == 1}`) - const l2usdc = new ethers.Contract(taskArgs.l2usdcproxy,new ethers.utils.Interface(V2_1ABI)) + const l2usdc = new ethers.Contract(taskArgs.l2usdcproxy, new ethers.utils.Interface(V2_1ABI)) res = await l2usdc.connect(deployer).initializeV2("USD Coin") rec = await res.wait() @@ -501,3 +499,115 @@ task("upgrade-l2-usdc-v2-1") rec = await res.wait() console.log(`l2 usdc initializeV2_1 ${rec.status == 1}`) }) + +task("deploy-l1-proxy") + .addParam("proxyadmin") + .addParam("empty") + .setAction(async (taskArgs, hre) => { + // params check + if (!ethers.utils.isAddress(taskArgs.proxyadmin) || + !ethers.utils.isAddress(taskArgs.empty) + ) { + console.error(`address params check failed`) + return + } + + const TransparentProxyFactory = await hre.ethers.getContractFactory("TransparentUpgradeableProxy") + const proxy = await TransparentProxyFactory.deploy( + taskArgs.empty, //logic + taskArgs.proxyadmin, //admin + "0x" + ) + await proxy.deployed() + console.log(`proxy deployed at ${proxy.address}`) + }) + + +task("deploy-l2-usdcgateway") + .addParam("proxyadmin") + .addParam("l1token") + .addParam("l2token") + .addParam("counterpart") + .addParam("router") + .addParam("messenger") + .setAction(async (taskArgs, hre) => { + // params check + if (!ethers.utils.isAddress(taskArgs.proxyadmin) || + !ethers.utils.isAddress(taskArgs.l1token) || + !ethers.utils.isAddress(taskArgs.l2token) || + !ethers.utils.isAddress(taskArgs.counterpart) || + !ethers.utils.isAddress(taskArgs.router) || + !ethers.utils.isAddress(taskArgs.messenger) + ) { + console.error(`address params check failed`) + return + } + // deploy gateway impl + const GatewayFactory = await hre.ethers.getContractFactory("L2USDCGateway") + const gateway = await GatewayFactory.deploy(taskArgs.l1token, taskArgs.l2token) + await gateway.deployed() + console.log(`gateway impl deployed at ${gateway.address}`) + + const TransparentProxyFactory = await hre.ethers.getContractFactory("TransparentUpgradeableProxy") + const proxy = await TransparentProxyFactory.deploy( + gateway.address, //logic + taskArgs.proxyadmin, //admin + GatewayFactory.interface.encodeFunctionData("initialize", [ + taskArgs.counterpart, + taskArgs.router, + taskArgs.messenger + ] + ) + ) + await proxy.deployed() + console.log(`gateway proxy deployed at ${proxy.address}`) + + const gatewayProxy = GatewayFactory.attach(proxy.address) + const owner = await gatewayProxy.owner() + const counterpart = await gatewayProxy.counterpart() + const router = await gatewayProxy.router() + const messenger = await gatewayProxy.messenger() + const l1USDC = await gatewayProxy.l1USDC() + const l2USDC = await gatewayProxy.l2USDC() + console.log(`owner ${owner}, gatewayProxy ${gatewayProxy.address}, counterpart ${counterpart}, router ${router}, messenger ${messenger}, l1USDC ${l1USDC}, l2USDC ${l2USDC}`) + }) + +task("deploy-l2-MigrationUSDC") + .addParam("proxyadmin") + .addParam("oldtoken") + .addParam("newtoken") + .addParam("recipient") + .setAction(async (taskArgs, hre) => { + // params check + if (!ethers.utils.isAddress(taskArgs.proxyadmin) || + !ethers.utils.isAddress(taskArgs.oldtoken) || + !ethers.utils.isAddress(taskArgs.recipient) || + !ethers.utils.isAddress(taskArgs.newtoken) + ) { + console.error(`address params check failed`) + return + } + // deploy gateway impl + const ContractFactory = await hre.ethers.getContractFactory("MigrationUSDC") + const contract = await ContractFactory.deploy(taskArgs.oldtoken, taskArgs.newtoken) + await contract.deployed() + console.log(`MigrationUSDC impl deployed at ${contract.address}`) + + const TransparentProxyFactory = await hre.ethers.getContractFactory("TransparentUpgradeableProxy") + const proxy = await TransparentProxyFactory.deploy( + contract.address, //logic + taskArgs.proxyadmin, //admin + ContractFactory.interface.encodeFunctionData("initialize", [ + taskArgs.recipient + ] + ) + ) + await proxy.deployed() + console.log(`MigrationUSDC proxy deployed at ${proxy.address}`) + + const migrationProxy = ContractFactory.attach(proxy.address) + const owner = await migrationProxy.owner() + const oldtoken = await migrationProxy.OLD_USDC() + const newtoken = await migrationProxy.NEW_USDC() + console.log(`owner ${owner}, oldtoken ${oldtoken}, newtoken ${newtoken}`) + }) \ No newline at end of file