{{ "language": "Solidity", "sources": { "lib/solmate/src/tokens/ERC20.sol": { "content": "// SPDX-License-Identifier: AGPL-3.0-only\npragma solidity >=0.8.0;\n\n/// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.\n/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol)\n/// @author Modified from Uniswap (https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol)\n/// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it.\nabstract contract ERC20 {\n /*//////////////////////////////////////////////////////////////\n EVENTS\n //////////////////////////////////////////////////////////////*/\n\n event Transfer(address indexed from, address indexed to, uint256 amount);\n\n event Approval(address indexed owner, address indexed spender, uint256 amount);\n\n /*//////////////////////////////////////////////////////////////\n METADATA STORAGE\n //////////////////////////////////////////////////////////////*/\n\n string public name;\n\n string public symbol;\n\n uint8 public immutable decimals;\n\n /*//////////////////////////////////////////////////////////////\n ERC20 STORAGE\n //////////////////////////////////////////////////////////////*/\n\n uint256 public totalSupply;\n\n mapping(address => uint256) public balanceOf;\n\n mapping(address => mapping(address => uint256)) public allowance;\n\n /*//////////////////////////////////////////////////////////////\n EIP-2612 STORAGE\n //////////////////////////////////////////////////////////////*/\n\n uint256 internal immutable INITIAL_CHAIN_ID;\n\n bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;\n\n mapping(address => uint256) public nonces;\n\n /*//////////////////////////////////////////////////////////////\n CONSTRUCTOR\n //////////////////////////////////////////////////////////////*/\n\n constructor(\n string memory _name,\n string memory _symbol,\n uint8 _decimals\n ) {\n name = _name;\n symbol = _symbol;\n decimals = _decimals;\n\n INITIAL_CHAIN_ID = block.chainid;\n INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();\n }\n\n /*//////////////////////////////////////////////////////////////\n ERC20 LOGIC\n //////////////////////////////////////////////////////////////*/\n\n function approve(address spender, uint256 amount) public virtual returns (bool) {\n allowance[msg.sender][spender] = amount;\n\n emit Approval(msg.sender, spender, amount);\n\n return true;\n }\n\n function transfer(address to, uint256 amount) public virtual returns (bool) {\n balanceOf[msg.sender] -= amount;\n\n // Cannot overflow because the sum of all user\n // balances can't exceed the max uint256 value.\n unchecked {\n balanceOf[to] += amount;\n }\n\n emit Transfer(msg.sender, to, amount);\n\n return true;\n }\n\n function transferFrom(\n address from,\n address to,\n uint256 amount\n ) public virtual returns (bool) {\n uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals.\n\n if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;\n\n balanceOf[from] -= amount;\n\n // Cannot overflow because the sum of all user\n // balances can't exceed the max uint256 value.\n unchecked {\n balanceOf[to] += amount;\n }\n\n emit Transfer(from, to, amount);\n\n return true;\n }\n\n /*//////////////////////////////////////////////////////////////\n EIP-2612 LOGIC\n //////////////////////////////////////////////////////////////*/\n\n function permit(\n address owner,\n address spender,\n uint256 value,\n uint256 deadline,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) public virtual {\n require(deadline >= block.timestamp, \"PERMIT_DEADLINE_EXPIRED\");\n\n // Unchecked because the only math done is incrementing\n // the owner's nonce which cannot realistically overflow.\n unchecked {\n address recoveredAddress = ecrecover(\n keccak256(\n abi.encodePacked(\n \"\\x19\\x01\",\n DOMAIN_SEPARATOR(),\n keccak256(\n abi.encode(\n keccak256(\n \"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\"\n ),\n owner,\n spender,\n value,\n nonces[owner]++,\n deadline\n )\n )\n )\n ),\n v,\n r,\n s\n );\n\n require(recoveredAddress != address(0) && recoveredAddress == owner, \"INVALID_SIGNER\");\n\n allowance[recoveredAddress][spender] = value;\n }\n\n emit Approval(owner, spender, value);\n }\n\n function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {\n return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();\n }\n\n function computeDomainSeparator() internal view virtual returns (bytes32) {\n return\n keccak256(\n abi.encode(\n keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\"),\n keccak256(bytes(name)),\n keccak256(\"1\"),\n block.chainid,\n address(this)\n )\n );\n }\n\n /*//////////////////////////////////////////////////////////////\n INTERNAL MINT/BURN LOGIC\n //////////////////////////////////////////////////////////////*/\n\n function _mint(address to, uint256 amount) internal virtual {\n totalSupply += amount;\n\n // Cannot overflow because the sum of all user\n // balances can't exceed the max uint256 value.\n unchecked {\n balanceOf[to] += amount;\n }\n\n emit Transfer(address(0), to, amount);\n }\n\n function _burn(address from, uint256 amount) internal virtual {\n balanceOf[from] -= amount;\n\n // Cannot underflow because a user's balance\n // will never be larger than the total supply.\n unchecked {\n totalSupply -= amount;\n }\n\n emit Transfer(from, address(0), amount);\n }\n}\n" }, "lib/solmate/src/utils/SafeTransferLib.sol": { "content": "// SPDX-License-Identifier: AGPL-3.0-only\npragma solidity >=0.8.0;\n\nimport {ERC20} from \"../tokens/ERC20.sol\";\n\n/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.\n/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol)\n/// @dev Use with caution! Some functions in this library knowingly create dirty bits at the destination of the free memory pointer.\n/// @dev Note that none of the functions in this library check that a token has code at all! That responsibility is delegated to the caller.\nlibrary SafeTransferLib {\n /*//////////////////////////////////////////////////////////////\n ETH OPERATIONS\n //////////////////////////////////////////////////////////////*/\n\n function safeTransferETH(address to, uint256 amount) internal {\n bool success;\n\n /// @solidity memory-safe-assembly\n assembly {\n // Transfer the ETH and store if it succeeded or not.\n success := call(gas(), to, amount, 0, 0, 0, 0)\n }\n\n require(success, \"ETH_TRANSFER_FAILED\");\n }\n\n /*//////////////////////////////////////////////////////////////\n ERC20 OPERATIONS\n //////////////////////////////////////////////////////////////*/\n\n function safeTransferFrom(\n ERC20 token,\n address from,\n address to,\n uint256 amount\n ) internal {\n bool success;\n\n /// @solidity memory-safe-assembly\n assembly {\n // Get a pointer to some free memory.\n let freeMemoryPointer := mload(0x40)\n\n // Write the abi-encoded calldata into memory, beginning with the function selector.\n mstore(freeMemoryPointer, 0x23b872dd00000000000000000000000000000000000000000000000000000000)\n mstore(add(freeMemoryPointer, 4), from) // Append the \"from\" argument.\n mstore(add(freeMemoryPointer, 36), to) // Append the \"to\" argument.\n mstore(add(freeMemoryPointer, 68), amount) // Append the \"amount\" argument.\n\n success := and(\n // Set success to whether the call reverted, if not we check it either\n // returned exactly 1 (can't just be non-zero data), or had no return data.\n or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),\n // We use 100 because the length of our calldata totals up like so: 4 + 32 * 3.\n // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space.\n // Counterintuitively, this call must be positioned second to the or() call in the\n // surrounding and() call or else returndatasize() will be zero during the computation.\n call(gas(), token, 0, freeMemoryPointer, 100, 0, 32)\n )\n }\n\n require(success, \"TRANSFER_FROM_FAILED\");\n }\n\n function safeTransfer(\n ERC20 token,\n address to,\n uint256 amount\n ) internal {\n bool success;\n\n /// @solidity memory-safe-assembly\n assembly {\n // Get a pointer to some free memory.\n let freeMemoryPointer := mload(0x40)\n\n // Write the abi-encoded calldata into memory, beginning with the function selector.\n mstore(freeMemoryPointer, 0xa9059cbb00000000000000000000000000000000000000000000000000000000)\n mstore(add(freeMemoryPointer, 4), to) // Append the \"to\" argument.\n mstore(add(freeMemoryPointer, 36), amount) // Append the \"amount\" argument.\n\n success := and(\n // Set success to whether the call reverted, if not we check it either\n // returned exactly 1 (can't just be non-zero data), or had no return data.\n or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),\n // We use 68 because the length of our calldata totals up like so: 4 + 32 * 2.\n // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space.\n // Counterintuitively, this call must be positioned second to the or() call in the\n // surrounding and() call or else returndatasize() will be zero during the computation.\n call(gas(), token, 0, freeMemoryPointer, 68, 0, 32)\n )\n }\n\n require(success, \"TRANSFER_FAILED\");\n }\n\n function safeApprove(\n ERC20 token,\n address to,\n uint256 amount\n ) internal {\n bool success;\n\n /// @solidity memory-safe-assembly\n assembly {\n // Get a pointer to some free memory.\n let freeMemoryPointer := mload(0x40)\n\n // Write the abi-encoded calldata into memory, beginning with the function selector.\n mstore(freeMemoryPointer, 0x095ea7b300000000000000000000000000000000000000000000000000000000)\n mstore(add(freeMemoryPointer, 4), to) // Append the \"to\" argument.\n mstore(add(freeMemoryPointer, 36), amount) // Append the \"amount\" argument.\n\n success := and(\n // Set success to whether the call reverted, if not we check it either\n // returned exactly 1 (can't just be non-zero data), or had no return data.\n or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),\n // We use 68 because the length of our calldata totals up like so: 4 + 32 * 2.\n // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space.\n // Counterintuitively, this call must be positioned second to the or() call in the\n // surrounding and() call or else returndatasize() will be zero during the computation.\n call(gas(), token, 0, freeMemoryPointer, 68, 0, 32)\n )\n }\n\n require(success, \"APPROVE_FAILED\");\n }\n}\n" }, "src/AllowanceTransfer.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.17;\n\nimport {ERC20} from \"solmate/tokens/ERC20.sol\";\nimport {SafeTransferLib} from \"solmate/utils/SafeTransferLib.sol\";\nimport {PermitHash} from \"./libraries/PermitHash.sol\";\nimport {SignatureVerification} from \"./libraries/SignatureVerification.sol\";\nimport {EIP712} from \"./EIP712.sol\";\nimport {IAllowanceTransfer} from \"../src/interfaces/IAllowanceTransfer.sol\";\nimport {SignatureExpired, InvalidNonce} from \"./PermitErrors.sol\";\nimport {Allowance} from \"./libraries/Allowance.sol\";\n\ncontract AllowanceTransfer is IAllowanceTransfer, EIP712 {\n using SignatureVerification for bytes;\n using SafeTransferLib for ERC20;\n using PermitHash for PermitSingle;\n using PermitHash for PermitBatch;\n using Allowance for PackedAllowance;\n\n /// @notice Maps users to tokens to spender addresses and information about the approval on the token\n /// @dev Indexed in the order of token owner address, token address, spender address\n /// @dev The stored word saves the allowed amount, expiration on the allowance, and nonce\n mapping(address => mapping(address => mapping(address => PackedAllowance))) public allowance;\n\n /// @inheritdoc IAllowanceTransfer\n function approve(address token, address spender, uint160 amount, uint48 expiration) external {\n PackedAllowance storage allowed = allowance[msg.sender][token][spender];\n allowed.updateAmountAndExpiration(amount, expiration);\n emit Approval(msg.sender, token, spender, amount, expiration);\n }\n\n /// @inheritdoc IAllowanceTransfer\n function permit(address owner, PermitSingle memory permitSingle, bytes calldata signature) external {\n if (block.timestamp > permitSingle.sigDeadline) revert SignatureExpired(permitSingle.sigDeadline);\n\n // Verify the signer address from the signature.\n signature.verify(_hashTypedData(permitSingle.hash()), owner);\n\n _updateApproval(permitSingle.details, owner, permitSingle.spender);\n }\n\n /// @inheritdoc IAllowanceTransfer\n function permit(address owner, PermitBatch memory permitBatch, bytes calldata signature) external {\n if (block.timestamp > permitBatch.sigDeadline) revert SignatureExpired(permitBatch.sigDeadline);\n\n // Verify the signer address from the signature.\n signature.verify(_hashTypedData(permitBatch.hash()), owner);\n\n address spender = permitBatch.spender;\n unchecked {\n uint256 length = permitBatch.details.length;\n for (uint256 i = 0; i < length; ++i) {\n _updateApproval(permitBatch.details[i], owner, spender);\n }\n }\n }\n\n /// @inheritdoc IAllowanceTransfer\n function transferFrom(address from, address to, uint160 amount, address token) external {\n _transfer(from, to, amount, token);\n }\n\n /// @inheritdoc IAllowanceTransfer\n function transferFrom(AllowanceTransferDetails[] calldata transferDetails) external {\n unchecked {\n uint256 length = transferDetails.length;\n for (uint256 i = 0; i < length; ++i) {\n AllowanceTransferDetails memory transferDetail = transferDetails[i];\n _transfer(transferDetail.from, transferDetail.to, transferDetail.amount, transferDetail.token);\n }\n }\n }\n\n /// @notice Internal function for transferring tokens using stored allowances\n /// @dev Will fail if the allowed timeframe has passed\n function _transfer(address from, address to, uint160 amount, address token) private {\n PackedAllowance storage allowed = allowance[from][token][msg.sender];\n\n if (block.timestamp > allowed.expiration) revert AllowanceExpired(allowed.expiration);\n\n uint256 maxAmount = allowed.amount;\n if (maxAmount != type(uint160).max) {\n if (amount > maxAmount) {\n revert InsufficientAllowance(maxAmount);\n } else {\n unchecked {\n allowed.amount = uint160(maxAmount) - amount;\n }\n }\n }\n\n // Transfer the tokens from the from address to the recipient.\n ERC20(token).safeTransferFrom(from, to, amount);\n }\n\n /// @inheritdoc IAllowanceTransfer\n function lockdown(TokenSpenderPair[] calldata approvals) external {\n address owner = msg.sender;\n // Revoke allowances for each pair of spenders and tokens.\n unchecked {\n uint256 length = approvals.length;\n for (uint256 i = 0; i < length; ++i) {\n address token = approvals[i].token;\n address spender = approvals[i].spender;\n\n allowance[owner][token][spender].amount = 0;\n emit Lockdown(owner, token, spender);\n }\n }\n }\n\n /// @inheritdoc IAllowanceTransfer\n function invalidateNonces(address token, address spender, uint48 newNonce) external {\n uint48 oldNonce = allowance[msg.sender][token][spender].nonce;\n\n if (newNonce <= oldNonce) revert InvalidNonce();\n\n // Limit the amount of nonces that can be invalidated in one transaction.\n unchecked {\n uint48 delta = newNonce - oldNonce;\n if (delta > type(uint16).max) revert ExcessiveInvalidation();\n }\n\n allowance[msg.sender][token][spender].nonce = newNonce;\n emit NonceInvalidation(msg.sender, token, spender, newNonce, oldNonce);\n }\n\n /// @notice Sets the new values for amount, expiration, and nonce.\n /// @dev Will check that the signed nonce is equal to the current nonce and then incrememnt the nonce value by 1.\n /// @dev Emits a Permit event.\n function _updateApproval(PermitDetails memory details, address owner, address spender) private {\n uint48 nonce = details.nonce;\n address token = details.token;\n uint160 amount = details.amount;\n uint48 expiration = details.expiration;\n PackedAllowance storage allowed = allowance[owner][token][spender];\n\n if (allowed.nonce != nonce) revert InvalidNonce();\n\n allowed.updateAll(amount, expiration, nonce);\n emit Permit(owner, token, spender, amount, expiration, nonce);\n }\n}\n" }, "src/EIP712.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.17;\n\n/// @notice EIP712 helpers for permit2\n/// @dev Maintains cross-chain replay protection in the event of a fork\n/// @dev Reference: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/EIP712.sol\ncontract EIP712 {\n // Cache the domain separator as an immutable value, but also store the chain id that it\n // corresponds to, in order to invalidate the cached domain separator if the chain id changes.\n bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;\n uint256 private immutable _CACHED_CHAIN_ID;\n\n bytes32 private constant _HASHED_NAME = keccak256(\"Permit2\");\n bytes32 private constant _TYPE_HASH =\n keccak256(\"EIP712Domain(string name,uint256 chainId,address verifyingContract)\");\n\n constructor() {\n _CACHED_CHAIN_ID = block.chainid;\n _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME);\n }\n\n /// @notice Returns the domain separator for the current chain.\n /// @dev Uses cached version if chainid and address are unchanged from construction.\n function DOMAIN_SEPARATOR() public view returns (bytes32) {\n return block.chainid == _CACHED_CHAIN_ID\n ? _CACHED_DOMAIN_SEPARATOR\n : _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME);\n }\n\n /// @notice Builds a domain separator using the current chainId and contract address.\n function _buildDomainSeparator(bytes32 typeHash, bytes32 nameHash) private view returns (bytes32) {\n return keccak256(abi.encode(typeHash, nameHash, block.chainid, address(this)));\n }\n\n /// @notice Creates an EIP-712 typed data hash\n function _hashTypedData(bytes32 dataHash) internal view returns (bytes32) {\n return keccak256(abi.encodePacked(\"\\x19\\x01\", DOMAIN_SEPARATOR(), dataHash));\n }\n}\n" }, "src/Permit2.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.17;\n\nimport {SignatureTransfer} from \"./SignatureTransfer.sol\";\nimport {AllowanceTransfer} from \"./AllowanceTransfer.sol\";\n\n/// @notice Permit2 handles signature-based transfers in SignatureTransfer and allowance-based transfers in AllowanceTransfer.\n/// @dev Users must approve Permit2 before calling any of the transfer functions.\ncontract Permit2 is SignatureTransfer, AllowanceTransfer {\n// Permit2 unifies the two contracts so users have maximal flexibility with their approval.\n}\n" }, "src/PermitErrors.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.17;\n\n/// @notice Shared errors between signature based transfers and allowance based transfers.\n\n/// @notice Thrown when validating an inputted signature that is stale\n/// @param signatureDeadline The timestamp at which a signature is no longer valid\nerror SignatureExpired(uint256 signatureDeadline);\n\n/// @notice Thrown when validating that the inputted nonce has not been used\nerror InvalidNonce();\n" }, "src/SignatureTransfer.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity 0.8.17;\n\nimport {ISignatureTransfer} from \"./interfaces/ISignatureTransfer.sol\";\nimport {SignatureExpired, InvalidNonce} from \"./PermitErrors.sol\";\nimport {ERC20} from \"solmate/tokens/ERC20.sol\";\nimport {SafeTransferLib} from \"solmate/utils/SafeTransferLib.sol\";\nimport {SignatureVerification} from \"./libraries/SignatureVerification.sol\";\nimport {PermitHash} from \"./libraries/PermitHash.sol\";\nimport {EIP712} from \"./EIP712.sol\";\n\ncontract SignatureTransfer is ISignatureTransfer, EIP712 {\n using SignatureVerification for bytes;\n using SafeTransferLib for ERC20;\n using PermitHash for PermitTransferFrom;\n using PermitHash for PermitBatchTransferFrom;\n\n /// @inheritdoc ISignatureTransfer\n mapping(address => mapping(uint256 => uint256)) public nonceBitmap;\n\n /// @inheritdoc ISignatureTransfer\n function permitTransferFrom(\n PermitTransferFrom memory permit,\n SignatureTransferDetails calldata transferDetails,\n address owner,\n bytes calldata signature\n ) external {\n _permitTransferFrom(permit, transferDetails, owner, permit.hash(), signature);\n }\n\n /// @inheritdoc ISignatureTransfer\n function permitWitnessTransferFrom(\n PermitTransferFrom memory permit,\n SignatureTransferDetails calldata transferDetails,\n address owner,\n bytes32 witness,\n string calldata witnessTypeString,\n bytes calldata signature\n ) external {\n _permitTransferFrom(\n permit, transferDetails, owner, permit.hashWithWitness(witness, witnessTypeString), signature\n );\n }\n\n /// @notice Transfers a token using a signed permit message.\n /// @dev If to is the zero address, the tokens are sent to the spender.\n /// @param permit The permit data signed over by the owner\n /// @param dataHash The EIP-712 hash of permit data to include when checking signature\n /// @param owner The owner of the tokens to transfer\n /// @param transferDetails The spender's requested transfer details for the permitted token\n /// @param signature The signature to verify\n function _permitTransferFrom(\n PermitTransferFrom memory permit,\n SignatureTransferDetails calldata transferDetails,\n address owner,\n bytes32 dataHash,\n bytes calldata signature\n ) private {\n uint256 requestedAmount = transferDetails.requestedAmount;\n\n if (block.timestamp > permit.deadline) revert SignatureExpired(permit.deadline);\n if (requestedAmount > permit.permitted.amount) revert InvalidAmount(permit.permitted.amount);\n\n _useUnorderedNonce(owner, permit.nonce);\n\n signature.verify(_hashTypedData(dataHash), owner);\n\n ERC20(permit.permitted.token).safeTransferFrom(owner, transferDetails.to, requestedAmount);\n }\n\n /// @inheritdoc ISignatureTransfer\n function permitTransferFrom(\n PermitBatchTransferFrom memory permit,\n SignatureTransferDetails[] calldata transferDetails,\n address owner,\n bytes calldata signature\n ) external {\n _permitTransferFrom(permit, transferDetails, owner, permit.hash(), signature);\n }\n\n /// @inheritdoc ISignatureTransfer\n function permitWitnessTransferFrom(\n PermitBatchTransferFrom memory permit,\n SignatureTransferDetails[] calldata transferDetails,\n address owner,\n bytes32 witness,\n string calldata witnessTypeString,\n bytes calldata signature\n ) external {\n _permitTransferFrom(\n permit, transferDetails, owner, permit.hashWithWitness(witness, witnessTypeString), signature\n );\n }\n\n /// @notice Transfers tokens using a signed permit messages\n /// @dev If to is the zero address, the tokens are sent to the spender\n /// @param permit The permit data signed over by the owner\n /// @param dataHash The EIP-712 hash of permit data to include when checking signature\n /// @param owner The owner of the tokens to transfer\n /// @param signature The signature to verify\n function _permitTransferFrom(\n PermitBatchTransferFrom memory permit,\n SignatureTransferDetails[] calldata transferDetails,\n address owner,\n bytes32 dataHash,\n bytes calldata signature\n ) private {\n uint256 numPermitted = permit.permitted.length;\n\n if (block.timestamp > permit.deadline) revert SignatureExpired(permit.deadline);\n if (numPermitted != transferDetails.length) revert LengthMismatch();\n\n _useUnorderedNonce(owner, permit.nonce);\n signature.verify(_hashTypedData(dataHash), owner);\n\n unchecked {\n for (uint256 i = 0; i < numPermitted; ++i) {\n TokenPermissions memory permitted = permit.permitted[i];\n uint256 requestedAmount = transferDetails[i].requestedAmount;\n\n if (requestedAmount > permitted.amount) revert InvalidAmount(permitted.amount);\n\n if (requestedAmount != 0) {\n // allow spender to specify which of the permitted tokens should be transferred\n ERC20(permitted.token).safeTransferFrom(owner, transferDetails[i].to, requestedAmount);\n }\n }\n }\n }\n\n /// @inheritdoc ISignatureTransfer\n function invalidateUnorderedNonces(uint256 wordPos, uint256 mask) external {\n nonceBitmap[msg.sender][wordPos] |= mask;\n\n emit UnorderedNonceInvalidation(msg.sender, wordPos, mask);\n }\n\n /// @notice Returns the index of the bitmap and the bit position within the bitmap. Used for unordered nonces\n /// @param nonce The nonce to get the associated word and bit positions\n /// @return wordPos The word position or index into the nonceBitmap\n /// @return bitPos The bit position\n /// @dev The first 248 bits of the nonce value is the index of the desired bitmap\n /// @dev The last 8 bits of the nonce value is the position of the bit in the bitmap\n function bitmapPositions(uint256 nonce) private pure returns (uint256 wordPos, uint256 bitPos) {\n wordPos = uint248(nonce >> 8);\n bitPos = uint8(nonce);\n }\n\n /// @notice Checks whether a nonce is taken and sets the bit at the bit position in the bitmap at the word position\n /// @param from The address to use the nonce at\n /// @param nonce The nonce to spend\n function _useUnorderedNonce(address from, uint256 nonce) internal {\n (uint256 wordPos, uint256 bitPos) = bitmapPositions(nonce);\n uint256 bit = 1 << bitPos;\n uint256 flipped = nonceBitmap[from][wordPos] ^= bit;\n\n if (flipped & bit == 0) revert InvalidNonce();\n }\n}\n" }, "src/interfaces/IAllowanceTransfer.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.17;\n\n/// @title AllowanceTransfer\n/// @notice Handles ERC20 token permissions through signature based allowance setting and ERC20 token transfers by checking allowed amounts\n/// @dev Requires user's token approval on the Permit2 contract\ninterface IAllowanceTransfer {\n /// @notice Thrown when an allowance on a token has expired.\n /// @param deadline The timestamp at which the allowed amount is no longer valid\n error AllowanceExpired(uint256 deadline);\n\n /// @notice Thrown when an allowance on a token has been depleted.\n /// @param amount The maximum amount allowed\n error InsufficientAllowance(uint256 amount);\n\n /// @notice Thrown when too many nonces are invalidated.\n error ExcessiveInvalidation();\n\n /// @notice Emits an event when the owner successfully invalidates an ordered nonce.\n event NonceInvalidation(\n address indexed owner, address indexed token, address indexed spender, uint48 newNonce, uint48 oldNonce\n );\n\n /// @notice Emits an event when the owner successfully sets permissions on a token for the spender.\n event Approval(\n address indexed owner, address indexed token, address indexed spender, uint160 amount, uint48 expiration\n );\n\n /// @notice Emits an event when the owner successfully sets permissions using a permit signature on a token for the spender.\n event Permit(\n address indexed owner,\n address indexed token,\n address indexed spender,\n uint160 amount,\n uint48 expiration,\n uint48 nonce\n );\n\n /// @notice Emits an event when the owner sets the allowance back to 0 with the lockdown function.\n event Lockdown(address indexed owner, address token, address spender);\n\n /// @notice The permit data for a token\n struct PermitDetails {\n // ERC20 token address\n address token;\n // the maximum amount allowed to spend\n uint160 amount;\n // timestamp at which a spender's token allowances become invalid\n uint48 expiration;\n // an incrementing value indexed per owner,token,and spender for each signature\n uint48 nonce;\n }\n\n /// @notice The permit message signed for a single token allownce\n struct PermitSingle {\n // the permit data for a single token alownce\n PermitDetails details;\n // address permissioned on the allowed tokens\n address spender;\n // deadline on the permit signature\n uint256 sigDeadline;\n }\n\n /// @notice The permit message signed for multiple token allowances\n struct PermitBatch {\n // the permit data for multiple token allowances\n PermitDetails[] details;\n // address permissioned on the allowed tokens\n address spender;\n // deadline on the permit signature\n uint256 sigDeadline;\n }\n\n /// @notice The saved permissions\n /// @dev This info is saved per owner, per token, per spender and all signed over in the permit message\n /// @dev Setting amount to type(uint160).max sets an unlimited approval\n struct PackedAllowance {\n // amount allowed\n uint160 amount;\n // permission expiry\n uint48 expiration;\n // an incrementing value indexed per owner,token,and spender for each signature\n uint48 nonce;\n }\n\n /// @notice A token spender pair.\n struct TokenSpenderPair {\n // the token the spender is approved\n address token;\n // the spender address\n address spender;\n }\n\n /// @notice Details for a token transfer.\n struct AllowanceTransferDetails {\n // the owner of the token\n address from;\n // the recipient of the token\n address to;\n // the amount of the token\n uint160 amount;\n // the token to be transferred\n address token;\n }\n\n /// @notice A mapping from owner address to token address to spender address to PackedAllowance struct, which contains details and conditions of the approval.\n /// @notice The mapping is indexed in the above order see: allowance[ownerAddress][tokenAddress][spenderAddress]\n /// @dev The packed slot holds the allowed amount, expiration at which the allowed amount is no longer valid, and current nonce thats updated on any signature based approvals.\n function allowance(address, address, address) external view returns (uint160, uint48, uint48);\n\n /// @notice Approves the spender to use up to amount of the specified token up until the expiration\n /// @param token The token to approve\n /// @param spender The spender address to approve\n /// @param amount The approved amount of the token\n /// @param expiration The timestamp at which the approval is no longer valid\n /// @dev The packed allowance also holds a nonce, which will stay unchanged in approve\n /// @dev Setting amount to type(uint160).max sets an unlimited approval\n function approve(address token, address spender, uint160 amount, uint48 expiration) external;\n\n /// @notice Permit a spender to a given amount of the owners token via the owner's EIP-712 signature\n /// @dev May fail if the owner's nonce was invalidated in-flight by invalidateNonce\n /// @param owner The owner of the tokens being approved\n /// @param permitSingle Data signed over by the owner specifying the terms of approval\n /// @param signature The owner's signature over the permit data\n function permit(address owner, PermitSingle memory permitSingle, bytes calldata signature) external;\n\n /// @notice Permit a spender to the signed amounts of the owners tokens via the owner's EIP-712 signature\n /// @dev May fail if the owner's nonce was invalidated in-flight by invalidateNonce\n /// @param owner The owner of the tokens being approved\n /// @param permitBatch Data signed over by the owner specifying the terms of approval\n /// @param signature The owner's signature over the permit data\n function permit(address owner, PermitBatch memory permitBatch, bytes calldata signature) external;\n\n /// @notice Transfer approved tokens from one address to another\n /// @param from The address to transfer from\n /// @param to The address of the recipient\n /// @param amount The amount of the token to transfer\n /// @param token The token address to transfer\n /// @dev Requires the from address to have approved at least the desired amount\n /// of tokens to msg.sender.\n function transferFrom(address from, address to, uint160 amount, address token) external;\n\n /// @notice Transfer approved tokens in a batch\n /// @param transferDetails Array of owners, recipients, amounts, and tokens for the transfers\n /// @dev Requires the from addresses to have approved at least the desired amount\n /// of tokens to msg.sender.\n function transferFrom(AllowanceTransferDetails[] calldata transferDetails) external;\n\n /// @notice Enables performing a \"lockdown\" of the sender's Permit2 identity\n /// by batch revoking approvals\n /// @param approvals Array of approvals to revoke.\n function lockdown(TokenSpenderPair[] calldata approvals) external;\n\n /// @notice Invalidate nonces for a given (token, spender) pair\n /// @param token The token to invalidate nonces for\n /// @param spender The spender to invalidate nonces for\n /// @param newNonce The new nonce to set. Invalidates all nonces less than it.\n /// @dev Can't invalidate more than 2**16 nonces per transaction.\n function invalidateNonces(address token, address spender, uint48 newNonce) external;\n}\n" }, "src/interfaces/IERC1271.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.17;\n\ninterface IERC1271 {\n /// @dev Should return whether the signature provided is valid for the provided data\n /// @param hash Hash of the data to be signed\n /// @param signature Signature byte array associated with _data\n /// @return magicValue The bytes4 magic value 0x1626ba7e\n function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);\n}\n" }, "src/interfaces/ISignatureTransfer.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.17;\n\n/// @title SignatureTransfer\n/// @notice Handles ERC20 token transfers through signature based actions\n/// @dev Requires user's token approval on the Permit2 contract\ninterface ISignatureTransfer {\n /// @notice Thrown when the requested amount for a transfer is larger than the permissioned amount\n /// @param maxAmount The maximum amount a spender can request to transfer\n error InvalidAmount(uint256 maxAmount);\n\n /// @notice Thrown when the number of tokens permissioned to a spender does not match the number of tokens being transferred\n /// @dev If the spender does not need to transfer the number of tokens permitted, the spender can request amount 0 to be transferred\n error LengthMismatch();\n\n /// @notice Emits an event when the owner successfully invalidates an unordered nonce.\n event UnorderedNonceInvalidation(address indexed owner, uint256 word, uint256 mask);\n\n /// @notice The token and amount details for a transfer signed in the permit transfer signature\n struct TokenPermissions {\n // ERC20 token address\n address token;\n // the maximum amount that can be spent\n uint256 amount;\n }\n\n /// @notice The signed permit message for a single token transfer\n struct PermitTransferFrom {\n TokenPermissions permitted;\n // a unique value for every token owner's signature to prevent signature replays\n uint256 nonce;\n // deadline on the permit signature\n uint256 deadline;\n }\n\n /// @notice Specifies the recipient address and amount for batched transfers.\n /// @dev Recipients and amounts correspond to the index of the signed token permissions array.\n /// @dev Reverts if the requested amount is greater than the permitted signed amount.\n struct SignatureTransferDetails {\n // recipient address\n address to;\n // spender requested amount\n uint256 requestedAmount;\n }\n\n /// @notice Used to reconstruct the signed permit message for multiple token transfers\n /// @dev Do not need to pass in spender address as it is required that it is msg.sender\n /// @dev Note that a user still signs over a spender address\n struct PermitBatchTransferFrom {\n // the tokens and corresponding amounts permitted for a transfer\n TokenPermissions[] permitted;\n // a unique value for every token owner's signature to prevent signature replays\n uint256 nonce;\n // deadline on the permit signature\n uint256 deadline;\n }\n\n /// @notice A map from token owner address and a caller specified word index to a bitmap. Used to set bits in the bitmap to prevent against signature replay protection\n /// @dev Uses unordered nonces so that permit messages do not need to be spent in a certain order\n /// @dev The mapping is indexed first by the token owner, then by an index specified in the nonce\n /// @dev It returns a uint256 bitmap\n /// @dev The index, or wordPosition is capped at type(uint248).max\n function nonceBitmap(address, uint256) external view returns (uint256);\n\n /// @notice Transfers a token using a signed permit message\n /// @dev Reverts if the requested amount is greater than the permitted signed amount\n /// @param permit The permit data signed over by the owner\n /// @param owner The owner of the tokens to transfer\n /// @param transferDetails The spender's requested transfer details for the permitted token\n /// @param signature The signature to verify\n function permitTransferFrom(\n PermitTransferFrom memory permit,\n SignatureTransferDetails calldata transferDetails,\n address owner,\n bytes calldata signature\n ) external;\n\n /// @notice Transfers a token using a signed permit message\n /// @notice Includes extra data provided by the caller to verify signature over\n /// @dev The witness type string must follow EIP712 ordering of nested structs and must include the TokenPermissions type definition\n /// @dev Reverts if the requested amount is greater than the permitted signed amount\n /// @param permit The permit data signed over by the owner\n /// @param owner The owner of the tokens to transfer\n /// @param transferDetails The spender's requested transfer details for the permitted token\n /// @param witness Extra data to include when checking the user signature\n /// @param witnessTypeString The EIP-712 type definition for remaining string stub of the typehash\n /// @param signature The signature to verify\n function permitWitnessTransferFrom(\n PermitTransferFrom memory permit,\n SignatureTransferDetails calldata transferDetails,\n address owner,\n bytes32 witness,\n string calldata witnessTypeString,\n bytes calldata signature\n ) external;\n\n /// @notice Transfers multiple tokens using a signed permit message\n /// @param permit The permit data signed over by the owner\n /// @param owner The owner of the tokens to transfer\n /// @param transferDetails Specifies the recipient and requested amount for the token transfer\n /// @param signature The signature to verify\n function permitTransferFrom(\n PermitBatchTransferFrom memory permit,\n SignatureTransferDetails[] calldata transferDetails,\n address owner,\n bytes calldata signature\n ) external;\n\n /// @notice Transfers multiple tokens using a signed permit message\n /// @dev The witness type string must follow EIP712 ordering of nested structs and must include the TokenPermissions type definition\n /// @notice Includes extra data provided by the caller to verify signature over\n /// @param permit The permit data signed over by the owner\n /// @param owner The owner of the tokens to transfer\n /// @param transferDetails Specifies the recipient and requested amount for the token transfer\n /// @param witness Extra data to include when checking the user signature\n /// @param witnessTypeString The EIP-712 type definition for remaining string stub of the typehash\n /// @param signature The signature to verify\n function permitWitnessTransferFrom(\n PermitBatchTransferFrom memory permit,\n SignatureTransferDetails[] calldata transferDetails,\n address owner,\n bytes32 witness,\n string calldata witnessTypeString,\n bytes calldata signature\n ) external;\n\n /// @notice Invalidates the bits specified in mask for the bitmap at the word position\n /// @dev The wordPos is maxed at type(uint248).max\n /// @param wordPos A number to index the nonceBitmap at\n /// @param mask A bitmap masked against msg.sender's current bitmap at the word position\n function invalidateUnorderedNonces(uint256 wordPos, uint256 mask) external;\n}\n" }, "src/libraries/Allowance.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.17;\n\nimport {IAllowanceTransfer} from \"../interfaces/IAllowanceTransfer.sol\";\n\nlibrary Allowance {\n // note if the expiration passed is 0, then it the approval set to the block.timestamp\n uint256 private constant BLOCK_TIMESTAMP_EXPIRATION = 0;\n\n /// @notice Sets the allowed amount, expiry, and nonce of the spender's permissions on owner's token.\n /// @dev Nonce is incremented.\n /// @dev If the inputted expiration is 0, the stored expiration is set to block.timestamp\n function updateAll(\n IAllowanceTransfer.PackedAllowance storage allowed,\n uint160 amount,\n uint48 expiration,\n uint48 nonce\n ) internal {\n uint48 storedNonce;\n unchecked {\n storedNonce = nonce + 1;\n }\n\n uint48 storedExpiration = expiration == BLOCK_TIMESTAMP_EXPIRATION ? uint48(block.timestamp) : expiration;\n\n uint256 word = pack(amount, storedExpiration, storedNonce);\n assembly {\n sstore(allowed.slot, word)\n }\n }\n\n /// @notice Sets the allowed amount and expiry of the spender's permissions on owner's token.\n /// @dev Nonce does not need to be incremented.\n function updateAmountAndExpiration(\n IAllowanceTransfer.PackedAllowance storage allowed,\n uint160 amount,\n uint48 expiration\n ) internal {\n // If the inputted expiration is 0, the allowance only lasts the duration of the block.\n allowed.expiration = expiration == 0 ? uint48(block.timestamp) : expiration;\n allowed.amount = amount;\n }\n\n /// @notice Computes the packed slot of the amount, expiration, and nonce that make up PackedAllowance\n function pack(uint160 amount, uint48 expiration, uint48 nonce) internal pure returns (uint256 word) {\n word = (uint256(nonce) << 208) | uint256(expiration) << 160 | amount;\n }\n}\n" }, "src/libraries/PermitHash.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.17;\n\nimport {IAllowanceTransfer} from \"../interfaces/IAllowanceTransfer.sol\";\nimport {ISignatureTransfer} from \"../interfaces/ISignatureTransfer.sol\";\n\nlibrary PermitHash {\n bytes32 public constant _PERMIT_DETAILS_TYPEHASH =\n keccak256(\"PermitDetails(address token,uint160 amount,uint48 expiration,uint48 nonce)\");\n\n bytes32 public constant _PERMIT_SINGLE_TYPEHASH = keccak256(\n \"PermitSingle(PermitDetails details,address spender,uint256 sigDeadline)PermitDetails(address token,uint160 amount,uint48 expiration,uint48 nonce)\"\n );\n\n bytes32 public constant _PERMIT_BATCH_TYPEHASH = keccak256(\n \"PermitBatch(PermitDetails[] details,address spender,uint256 sigDeadline)PermitDetails(address token,uint160 amount,uint48 expiration,uint48 nonce)\"\n );\n\n bytes32 public constant _TOKEN_PERMISSIONS_TYPEHASH = keccak256(\"TokenPermissions(address token,uint256 amount)\");\n\n bytes32 public constant _PERMIT_TRANSFER_FROM_TYPEHASH = keccak256(\n \"PermitTransferFrom(TokenPermissions permitted,address spender,uint256 nonce,uint256 deadline)TokenPermissions(address token,uint256 amount)\"\n );\n\n bytes32 public constant _PERMIT_BATCH_TRANSFER_FROM_TYPEHASH = keccak256(\n \"PermitBatchTransferFrom(TokenPermissions[] permitted,address spender,uint256 nonce,uint256 deadline)TokenPermissions(address token,uint256 amount)\"\n );\n\n string public constant _TOKEN_PERMISSIONS_TYPESTRING = \"TokenPermissions(address token,uint256 amount)\";\n\n string public constant _PERMIT_TRANSFER_FROM_WITNESS_TYPEHASH_STUB =\n \"PermitWitnessTransferFrom(TokenPermissions permitted,address spender,uint256 nonce,uint256 deadline,\";\n\n string public constant _PERMIT_BATCH_WITNESS_TRANSFER_FROM_TYPEHASH_STUB =\n \"PermitBatchWitnessTransferFrom(TokenPermissions[] permitted,address spender,uint256 nonce,uint256 deadline,\";\n\n function hash(IAllowanceTransfer.PermitSingle memory permitSingle) internal pure returns (bytes32) {\n bytes32 permitHash = _hashPermitDetails(permitSingle.details);\n return\n keccak256(abi.encode(_PERMIT_SINGLE_TYPEHASH, permitHash, permitSingle.spender, permitSingle.sigDeadline));\n }\n\n function hash(IAllowanceTransfer.PermitBatch memory permitBatch) internal pure returns (bytes32) {\n uint256 numPermits = permitBatch.details.length;\n bytes32[] memory permitHashes = new bytes32[](numPermits);\n for (uint256 i = 0; i < numPermits; ++i) {\n permitHashes[i] = _hashPermitDetails(permitBatch.details[i]);\n }\n return keccak256(\n abi.encode(\n _PERMIT_BATCH_TYPEHASH,\n keccak256(abi.encodePacked(permitHashes)),\n permitBatch.spender,\n permitBatch.sigDeadline\n )\n );\n }\n\n function hash(ISignatureTransfer.PermitTransferFrom memory permit) internal view returns (bytes32) {\n bytes32 tokenPermissionsHash = _hashTokenPermissions(permit.permitted);\n return keccak256(\n abi.encode(_PERMIT_TRANSFER_FROM_TYPEHASH, tokenPermissionsHash, msg.sender, permit.nonce, permit.deadline)\n );\n }\n\n function hash(ISignatureTransfer.PermitBatchTransferFrom memory permit) internal view returns (bytes32) {\n uint256 numPermitted = permit.permitted.length;\n bytes32[] memory tokenPermissionHashes = new bytes32[](numPermitted);\n\n for (uint256 i = 0; i < numPermitted; ++i) {\n tokenPermissionHashes[i] = _hashTokenPermissions(permit.permitted[i]);\n }\n\n return keccak256(\n abi.encode(\n _PERMIT_BATCH_TRANSFER_FROM_TYPEHASH,\n keccak256(abi.encodePacked(tokenPermissionHashes)),\n msg.sender,\n permit.nonce,\n permit.deadline\n )\n );\n }\n\n function hashWithWitness(\n ISignatureTransfer.PermitTransferFrom memory permit,\n bytes32 witness,\n string calldata witnessTypeString\n ) internal view returns (bytes32) {\n bytes32 typeHash = keccak256(abi.encodePacked(_PERMIT_TRANSFER_FROM_WITNESS_TYPEHASH_STUB, witnessTypeString));\n\n bytes32 tokenPermissionsHash = _hashTokenPermissions(permit.permitted);\n return keccak256(abi.encode(typeHash, tokenPermissionsHash, msg.sender, permit.nonce, permit.deadline, witness));\n }\n\n function hashWithWitness(\n ISignatureTransfer.PermitBatchTransferFrom memory permit,\n bytes32 witness,\n string calldata witnessTypeString\n ) internal view returns (bytes32) {\n bytes32 typeHash =\n keccak256(abi.encodePacked(_PERMIT_BATCH_WITNESS_TRANSFER_FROM_TYPEHASH_STUB, witnessTypeString));\n\n uint256 numPermitted = permit.permitted.length;\n bytes32[] memory tokenPermissionHashes = new bytes32[](numPermitted);\n\n for (uint256 i = 0; i < numPermitted; ++i) {\n tokenPermissionHashes[i] = _hashTokenPermissions(permit.permitted[i]);\n }\n\n return keccak256(\n abi.encode(\n typeHash,\n keccak256(abi.encodePacked(tokenPermissionHashes)),\n msg.sender,\n permit.nonce,\n permit.deadline,\n witness\n )\n );\n }\n\n function _hashPermitDetails(IAllowanceTransfer.PermitDetails memory details) private pure returns (bytes32) {\n return keccak256(abi.encode(_PERMIT_DETAILS_TYPEHASH, details));\n }\n\n function _hashTokenPermissions(ISignatureTransfer.TokenPermissions memory permitted)\n private\n pure\n returns (bytes32)\n {\n return keccak256(abi.encode(_TOKEN_PERMISSIONS_TYPEHASH, permitted));\n }\n}\n" }, "src/libraries/SignatureVerification.sol": { "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.17;\n\nimport {IERC1271} from \"../interfaces/IERC1271.sol\";\n\nlibrary SignatureVerification {\n /// @notice Thrown when the passed in signature is not a valid length\n error InvalidSignatureLength();\n\n /// @notice Thrown when the recovered signer is equal to the zero address\n error InvalidSignature();\n\n /// @notice Thrown when the recovered signer does not equal the claimedSigner\n error InvalidSigner();\n\n /// @notice Thrown when the recovered contract signature is incorrect\n error InvalidContractSignature();\n\n bytes32 constant UPPER_BIT_MASK = (0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);\n\n function verify(bytes calldata signature, bytes32 hash, address claimedSigner) internal view {\n bytes32 r;\n bytes32 s;\n uint8 v;\n\n if (claimedSigner.code.length == 0) {\n if (signature.length == 65) {\n (r, s) = abi.decode(signature, (bytes32, bytes32));\n v = uint8(signature[64]);\n } else if (signature.length == 64) {\n // EIP-2098\n bytes32 vs;\n (r, vs) = abi.decode(signature, (bytes32, bytes32));\n s = vs & UPPER_BIT_MASK;\n v = uint8(uint256(vs >> 255)) + 27;\n } else {\n revert InvalidSignatureLength();\n }\n address signer = ecrecover(hash, v, r, s);\n if (signer == address(0)) revert InvalidSignature();\n if (signer != claimedSigner) revert InvalidSigner();\n } else {\n bytes4 magicValue = IERC1271(claimedSigner).isValidSignature(hash, signature);\n if (magicValue != IERC1271.isValidSignature.selector) revert InvalidContractSignature();\n }\n }\n}\n" } }, "settings": { "remappings": [ "ds-test/=lib/solmate/lib/ds-test/src/", "forge-gas-snapshot/=lib/forge-gas-snapshot/src/", "forge-std/=lib/forge-std/src/", "openzeppelin-contracts/=lib/openzeppelin-contracts/", "solmate/=lib/solmate/src/" ], "optimizer": { "enabled": true, "runs": 1000000 }, "metadata": { "bytecodeHash": "none" }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "evmVersion": "london", "viaIR": true, "libraries": {} } }}

Permit2

Start building on QuickNode

Source code: