{"sources":{"src/contracts/CowProtocolToken.sol":{"content":"// SPDX-License-Identifier: LGPL-3.0-or-later\npragma solidity ^0.8.10;\n\nimport \"./mixins/InflationaryToken.sol\";\nimport \"./vendored/mixins/StorageAccessible.sol\";\n\n/// @dev The governance token for the CoW Protocol.\n/// @title CoW Protocol Governance Token\n/// @author CoW Protocol Developers\ncontract CowProtocolToken is InflationaryToken, StorageAccessible {\n string private constant ERC20_SYMBOL = \"COW\";\n string private constant ERC20_NAME = \"CoW Protocol Token\";\n\n constructor(\n address initialTokenHolder,\n address cowDao,\n uint256 totalSupply\n )\n InflationaryToken(\n initialTokenHolder,\n cowDao,\n totalSupply,\n ERC20_NAME,\n ERC20_SYMBOL\n )\n // solhint-disable-next-line no-empty-blocks\n {\n\n }\n}\n"},"src/contracts/vendored/mixins/ERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n\n// Vendored from OpenZeppelin Contracts v4.4.0, see:\n// \n// The following changes were made:\n// - Vendored imports\n\n// OpenZeppelin Contracts v4.4.0 (token/ERC20/ERC20.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../interfaces/IERC20.sol\";\nimport \"../interfaces/IERC20Metadata.sol\";\nimport \"../interfaces/Context.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20PresetMinterPauser}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\n * instead returning `false` on failure. This behavior is nonetheless\n * conventional and does not conflict with the expectations of ERC20\n * applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20 is Context, IERC20, IERC20Metadata {\n mapping(address => uint256) private _balances;\n\n mapping(address => mapping(address => uint256)) private _allowances;\n\n uint256 private _totalSupply;\n\n string private _name;\n string private _symbol;\n\n /**\n * @dev Sets the values for {name} and {symbol}.\n *\n * The default value of {decimals} is 18. To select a different value for\n * {decimals} you should overload it.\n *\n * All two of these values are immutable: they can only be set once during\n * construction.\n */\n constructor(string memory name_, string memory symbol_) {\n _name = name_;\n _symbol = symbol_;\n }\n\n /**\n * @dev Returns the name of the token.\n */\n function name() public view virtual override returns (string memory) {\n return _name;\n }\n\n /**\n * @dev Returns the symbol of the token, usually a shorter version of the\n * name.\n */\n function symbol() public view virtual override returns (string memory) {\n return _symbol;\n }\n\n /**\n * @dev Returns the number of decimals used to get its user representation.\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\n * be displayed to a user as `5.05` (`505 / 10 ** 2`).\n *\n * Tokens usually opt for a value of 18, imitating the relationship between\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\n * overridden;\n *\n * NOTE: This information is only used for _display_ purposes: it in\n * no way affects any of the arithmetic of the contract, including\n * {IERC20-balanceOf} and {IERC20-transfer}.\n */\n function decimals() public view virtual override returns (uint8) {\n return 18;\n }\n\n /**\n * @dev See {IERC20-totalSupply}.\n */\n function totalSupply() public view virtual override returns (uint256) {\n return _totalSupply;\n }\n\n /**\n * @dev See {IERC20-balanceOf}.\n */\n function balanceOf(address account)\n public\n view\n virtual\n override\n returns (uint256)\n {\n return _balances[account];\n }\n\n /**\n * @dev See {IERC20-transfer}.\n *\n * Requirements:\n *\n * - `recipient` cannot be the zero address.\n * - the caller must have a balance of at least `amount`.\n */\n function transfer(address recipient, uint256 amount)\n public\n virtual\n override\n returns (bool)\n {\n _transfer(_msgSender(), recipient, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-allowance}.\n */\n function allowance(address owner, address spender)\n public\n view\n virtual\n override\n returns (uint256)\n {\n return _allowances[owner][spender];\n }\n\n /**\n * @dev See {IERC20-approve}.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function approve(address spender, uint256 amount)\n public\n virtual\n override\n returns (bool)\n {\n _approve(_msgSender(), spender, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-transferFrom}.\n *\n * Emits an {Approval} event indicating the updated allowance. This is not\n * required by the EIP. See the note at the beginning of {ERC20}.\n *\n * Requirements:\n *\n * - `sender` and `recipient` cannot be the zero address.\n * - `sender` must have a balance of at least `amount`.\n * - the caller must have allowance for ``sender``'s tokens of at least\n * `amount`.\n */\n function transferFrom(\n address sender,\n address recipient,\n uint256 amount\n ) public virtual override returns (bool) {\n _transfer(sender, recipient, amount);\n\n uint256 currentAllowance = _allowances[sender][_msgSender()];\n require(\n currentAllowance >= amount,\n \"ERC20: transfer amount exceeds allowance\"\n );\n unchecked {\n _approve(sender, _msgSender(), currentAllowance - amount);\n }\n\n return true;\n }\n\n /**\n * @dev Atomically increases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function increaseAllowance(address spender, uint256 addedValue)\n public\n virtual\n returns (bool)\n {\n _approve(\n _msgSender(),\n spender,\n _allowances[_msgSender()][spender] + addedValue\n );\n return true;\n }\n\n /**\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n * - `spender` must have allowance for the caller of at least\n * `subtractedValue`.\n */\n function decreaseAllowance(address spender, uint256 subtractedValue)\n public\n virtual\n returns (bool)\n {\n uint256 currentAllowance = _allowances[_msgSender()][spender];\n require(\n currentAllowance >= subtractedValue,\n \"ERC20: decreased allowance below zero\"\n );\n unchecked {\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\n }\n\n return true;\n }\n\n /**\n * @dev Moves `amount` of tokens from `sender` to `recipient`.\n *\n * This internal function is equivalent to {transfer}, and can be used to\n * e.g. implement automatic token fees, slashing mechanisms, etc.\n *\n * Emits a {Transfer} event.\n *\n * Requirements:\n *\n * - `sender` cannot be the zero address.\n * - `recipient` cannot be the zero address.\n * - `sender` must have a balance of at least `amount`.\n */\n function _transfer(\n address sender,\n address recipient,\n uint256 amount\n ) internal virtual {\n require(sender != address(0), \"ERC20: transfer from the zero address\");\n require(recipient != address(0), \"ERC20: transfer to the zero address\");\n\n _beforeTokenTransfer(sender, recipient, amount);\n\n uint256 senderBalance = _balances[sender];\n require(\n senderBalance >= amount,\n \"ERC20: transfer amount exceeds balance\"\n );\n unchecked {\n _balances[sender] = senderBalance - amount;\n }\n _balances[recipient] += amount;\n\n emit Transfer(sender, recipient, amount);\n\n _afterTokenTransfer(sender, recipient, amount);\n }\n\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n * the total supply.\n *\n * Emits a {Transfer} event with `from` set to the zero address.\n *\n * Requirements:\n *\n * - `account` cannot be the zero address.\n */\n function _mint(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: mint to the zero address\");\n\n _beforeTokenTransfer(address(0), account, amount);\n\n _totalSupply += amount;\n _balances[account] += amount;\n emit Transfer(address(0), account, amount);\n\n _afterTokenTransfer(address(0), account, amount);\n }\n\n /**\n * @dev Destroys `amount` tokens from `account`, reducing the\n * total supply.\n *\n * Emits a {Transfer} event with `to` set to the zero address.\n *\n * Requirements:\n *\n * - `account` cannot be the zero address.\n * - `account` must have at least `amount` tokens.\n */\n function _burn(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: burn from the zero address\");\n\n _beforeTokenTransfer(account, address(0), amount);\n\n uint256 accountBalance = _balances[account];\n require(accountBalance >= amount, \"ERC20: burn amount exceeds balance\");\n unchecked {\n _balances[account] = accountBalance - amount;\n }\n _totalSupply -= amount;\n\n emit Transfer(account, address(0), amount);\n\n _afterTokenTransfer(account, address(0), amount);\n }\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n *\n * This internal function is equivalent to `approve`, and can be used to\n * e.g. set automatic allowances for certain subsystems, etc.\n *\n * Emits an {Approval} event.\n *\n * Requirements:\n *\n * - `owner` cannot be the zero address.\n * - `spender` cannot be the zero address.\n */\n function _approve(\n address owner,\n address spender,\n uint256 amount\n ) internal virtual {\n require(owner != address(0), \"ERC20: approve from the zero address\");\n require(spender != address(0), \"ERC20: approve to the zero address\");\n\n _allowances[owner][spender] = amount;\n emit Approval(owner, spender, amount);\n }\n\n /**\n * @dev Hook that is called before any transfer of tokens. This includes\n * minting and burning.\n *\n * Calling conditions:\n *\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n * will be transferred to `to`.\n * - when `from` is zero, `amount` tokens will be minted for `to`.\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n * - `from` and `to` are never both zero.\n *\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n */\n function _beforeTokenTransfer(\n address from,\n address to,\n uint256 amount\n ) internal virtual {}\n\n /**\n * @dev Hook that is called after any transfer of tokens. This includes\n * minting and burning.\n *\n * Calling conditions:\n *\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n * has been transferred to `to`.\n * - when `from` is zero, `amount` tokens have been minted for `to`.\n * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\n * - `from` and `to` are never both zero.\n *\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n */\n function _afterTokenTransfer(\n address from,\n address to,\n uint256 amount\n ) internal virtual {}\n}\n"},"src/contracts/mixins/InflationaryToken.sol":{"content":"// SPDX-License-Identifier: LGPL-3.0-or-later\npragma solidity ^0.8.10;\n\nimport \"../vendored/mixins/ERC20.sol\";\nimport \"../vendored/mixins/draft-ERC20Permit.sol\";\n\n/// @dev Contract contains the logic for minting new tokens\n/// @title Mintable Token\n/// @author CoW Protocol Developers\ncontract InflationaryToken is ERC20, ERC20Permit {\n /// @dev Defines the cowDao address that is allowed to mint new tokens\n address public immutable cowDao;\n /// @dev Defines how frequently inflation can be triggered: Once a year\n uint256 public constant TIME_BETWEEN_MINTINGS = 365 days;\n /// @dev Defines the maximal inflation per year\n uint256 public constant MAX_YEARLY_INFLATION = 3;\n /// @dev Stores the timestamp of the last inflation event\n uint256 public timestampLastMinting = 0;\n\n /// @dev Error caused by an attempt to mint too many tokens.\n error ExceedingMintCap();\n /// @dev Error caused by calling the mint function more than once within one year.\n error AlreadyInflated();\n /// @dev Error caused by calling the mint function from a non-cowDao account.\n error OnlyCowDao();\n\n modifier onlyCowDao() {\n if (msg.sender != cowDao) {\n revert OnlyCowDao();\n }\n _;\n }\n\n constructor(\n address initialTokenHolder,\n address _cowDao,\n uint256 totalSupply,\n string memory erc20Name,\n string memory erc20Symbol\n ) ERC20(erc20Name, erc20Symbol) ERC20Permit(erc20Name) {\n _mint(initialTokenHolder, totalSupply);\n cowDao = _cowDao;\n // solhint-disable-next-line not-rely-on-time\n timestampLastMinting = block.timestamp;\n }\n\n /// @dev This function allows to mint new tokens\n /// @param target The address that should receive the new tokens\n /// @param amount The amount of tokens to be minted.\n function mint(address target, uint256 amount) external onlyCowDao {\n if (amount > (totalSupply() * MAX_YEARLY_INFLATION) / 100) {\n revert ExceedingMintCap();\n }\n // solhint-disable-next-line not-rely-on-time\n if (timestampLastMinting + TIME_BETWEEN_MINTINGS > block.timestamp) {\n revert AlreadyInflated();\n }\n timestampLastMinting = block.timestamp; // solhint-disable-line not-rely-on-time\n _mint(target, amount);\n }\n}\n"},"src/contracts/vendored/libraries/ECDSA.sol":{"content":"// SPDX-License-Identifier: MIT\n\n// Vendored from OpenZeppelin Contracts v4.4.0, see:\n// \n// The following changes were made:\n// - Vendored imports\n\n// OpenZeppelin Contracts v4.4.0 (utils/cryptography/ECDSA.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./Strings.sol\";\n\n/**\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\n *\n * These functions can be used to verify that a message was signed by the holder\n * of the private keys of a given address.\n */\nlibrary ECDSA {\n enum RecoverError {\n NoError,\n InvalidSignature,\n InvalidSignatureLength,\n InvalidSignatureS,\n InvalidSignatureV\n }\n\n function _throwError(RecoverError error) private pure {\n if (error == RecoverError.NoError) {\n return; // no error: do nothing\n } else if (error == RecoverError.InvalidSignature) {\n revert(\"ECDSA: invalid signature\");\n } else if (error == RecoverError.InvalidSignatureLength) {\n revert(\"ECDSA: invalid signature length\");\n } else if (error == RecoverError.InvalidSignatureS) {\n revert(\"ECDSA: invalid signature 's' value\");\n } else if (error == RecoverError.InvalidSignatureV) {\n revert(\"ECDSA: invalid signature 'v' value\");\n }\n }\n\n /**\n * @dev Returns the address that signed a hashed message (`hash`) with\n * `signature` or error string. This address can then be used for verification purposes.\n *\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\n * this function rejects them by requiring the `s` value to be in the lower\n * half order, and the `v` value to be either 27 or 28.\n *\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n * verification to be secure: it is possible to craft signatures that\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n * this is by receiving a hash of the original message (which may otherwise\n * be too long), and then calling {toEthSignedMessageHash} on it.\n *\n * Documentation for signature generation:\n * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\n * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]\n *\n * _Available since v4.3._\n */\n function tryRecover(bytes32 hash, bytes memory signature)\n internal\n pure\n returns (address, RecoverError)\n {\n // Check the signature length\n // - case 65: r,s,v signature (standard)\n // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._\n if (signature.length == 65) {\n bytes32 r;\n bytes32 s;\n uint8 v;\n // ecrecover takes the signature parameters, and the only way to get them\n // currently is to use assembly.\n assembly {\n r := mload(add(signature, 0x20))\n s := mload(add(signature, 0x40))\n v := byte(0, mload(add(signature, 0x60)))\n }\n return tryRecover(hash, v, r, s);\n } else if (signature.length == 64) {\n bytes32 r;\n bytes32 vs;\n // ecrecover takes the signature parameters, and the only way to get them\n // currently is to use assembly.\n assembly {\n r := mload(add(signature, 0x20))\n vs := mload(add(signature, 0x40))\n }\n return tryRecover(hash, r, vs);\n } else {\n return (address(0), RecoverError.InvalidSignatureLength);\n }\n }\n\n /**\n * @dev Returns the address that signed a hashed message (`hash`) with\n * `signature`. This address can then be used for verification purposes.\n *\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\n * this function rejects them by requiring the `s` value to be in the lower\n * half order, and the `v` value to be either 27 or 28.\n *\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n * verification to be secure: it is possible to craft signatures that\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n * this is by receiving a hash of the original message (which may otherwise\n * be too long), and then calling {toEthSignedMessageHash} on it.\n */\n function recover(bytes32 hash, bytes memory signature)\n internal\n pure\n returns (address)\n {\n (address recovered, RecoverError error) = tryRecover(hash, signature);\n _throwError(error);\n return recovered;\n }\n\n /**\n * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.\n *\n * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]\n *\n * _Available since v4.3._\n */\n function tryRecover(\n bytes32 hash,\n bytes32 r,\n bytes32 vs\n ) internal pure returns (address, RecoverError) {\n bytes32 s;\n uint8 v;\n assembly {\n s := and(\n vs,\n 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\n )\n v := add(shr(255, vs), 27)\n }\n return tryRecover(hash, v, r, s);\n }\n\n /**\n * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.\n *\n * _Available since v4.2._\n */\n function recover(\n bytes32 hash,\n bytes32 r,\n bytes32 vs\n ) internal pure returns (address) {\n (address recovered, RecoverError error) = tryRecover(hash, r, vs);\n _throwError(error);\n return recovered;\n }\n\n /**\n * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\n * `r` and `s` signature fields separately.\n *\n * _Available since v4.3._\n */\n function tryRecover(\n bytes32 hash,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) internal pure returns (address, RecoverError) {\n // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\n // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most\n // signatures from current libraries generate a unique signature with an s-value in the lower half order.\n //\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\n // these malleable signatures as well.\n if (\n uint256(s) >\n 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0\n ) {\n return (address(0), RecoverError.InvalidSignatureS);\n }\n if (v != 27 && v != 28) {\n return (address(0), RecoverError.InvalidSignatureV);\n }\n\n // If the signature is valid (and not malleable), return the signer address\n address signer = ecrecover(hash, v, r, s);\n if (signer == address(0)) {\n return (address(0), RecoverError.InvalidSignature);\n }\n\n return (signer, RecoverError.NoError);\n }\n\n /**\n * @dev Overload of {ECDSA-recover} that receives the `v`,\n * `r` and `s` signature fields separately.\n */\n function recover(\n bytes32 hash,\n uint8 v,\n bytes32 r,\n bytes32 s\n ) internal pure returns (address) {\n (address recovered, RecoverError error) = tryRecover(hash, v, r, s);\n _throwError(error);\n return recovered;\n }\n\n /**\n * @dev Returns an Ethereum Signed Message, created from a `hash`. This\n * produces hash corresponding to the one signed with the\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\n * JSON-RPC method as part of EIP-191.\n *\n * See {recover}.\n */\n function toEthSignedMessageHash(bytes32 hash)\n internal\n pure\n returns (bytes32)\n {\n // 32 is the length in bytes of hash,\n // enforced by the type signature above\n return\n keccak256(\n abi.encodePacked(\"\\x19Ethereum Signed Message:\\n32\", hash)\n );\n }\n\n /**\n * @dev Returns an Ethereum Signed Message, created from `s`. This\n * produces hash corresponding to the one signed with the\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\n * JSON-RPC method as part of EIP-191.\n *\n * See {recover}.\n */\n function toEthSignedMessageHash(bytes memory s)\n internal\n pure\n returns (bytes32)\n {\n return\n keccak256(\n abi.encodePacked(\n \"\\x19Ethereum Signed Message:\\n\",\n Strings.toString(s.length),\n s\n )\n );\n }\n\n /**\n * @dev Returns an Ethereum Signed Typed Data, created from a\n * `domainSeparator` and a `structHash`. This produces hash corresponding\n * to the one signed with the\n * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]\n * JSON-RPC method as part of EIP-712.\n *\n * See {recover}.\n */\n function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash)\n internal\n pure\n returns (bytes32)\n {\n return\n keccak256(\n abi.encodePacked(\"\\x19\\x01\", domainSeparator, structHash)\n );\n }\n}\n"},"src/contracts/vendored/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n\n// Vendored from OpenZeppelin Contracts v4.4.0, see:\n// \n\n// OpenZeppelin Contracts v4.4.0 (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n /**\n * @dev Returns the amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address recipient, uint256 amount)\n external\n returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender)\n external\n view\n returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\n * allowance mechanism. `amount` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(\n address sender,\n address recipient,\n uint256 amount\n ) external returns (bool);\n\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(\n address indexed owner,\n address indexed spender,\n uint256 value\n );\n}\n"},"src/contracts/vendored/libraries/Strings.sol":{"content":"// SPDX-License-Identifier: MIT\n\n// Vendored from OpenZeppelin Contracts v4.4.0, see:\n// \n\n// OpenZeppelin Contracts v4.4.0 (utils/Strings.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n bytes16 private constant _HEX_SYMBOLS = \"0123456789abcdef\";\n\n /**\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n */\n function toString(uint256 value) internal pure returns (string memory) {\n // Inspired by OraclizeAPI's implementation - MIT licence\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\n\n if (value == 0) {\n return \"0\";\n }\n uint256 temp = value;\n uint256 digits;\n while (temp != 0) {\n digits++;\n temp /= 10;\n }\n bytes memory buffer = new bytes(digits);\n while (value != 0) {\n digits -= 1;\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\n value /= 10;\n }\n return string(buffer);\n }\n\n /**\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n */\n function toHexString(uint256 value) internal pure returns (string memory) {\n if (value == 0) {\n return \"0x00\";\n }\n uint256 temp = value;\n uint256 length = 0;\n while (temp != 0) {\n length++;\n temp >>= 8;\n }\n return toHexString(value, length);\n }\n\n /**\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n */\n function toHexString(uint256 value, uint256 length)\n internal\n pure\n returns (string memory)\n {\n bytes memory buffer = new bytes(2 * length + 2);\n buffer[0] = \"0\";\n buffer[1] = \"x\";\n for (uint256 i = 2 * length + 1; i > 1; --i) {\n buffer[i] = _HEX_SYMBOLS[value & 0xf];\n value >>= 4;\n }\n require(value == 0, \"Strings: hex length insufficient\");\n return string(buffer);\n }\n}\n"},"src/contracts/vendored/interfaces/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n\n// Vendored from OpenZeppelin Contracts v4.4.0, see:\n// \n\n// OpenZeppelin Contracts v4.4.0 (utils/Context.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n function _msgSender() internal view virtual returns (address) {\n return msg.sender;\n }\n\n function _msgData() internal view virtual returns (bytes calldata) {\n return msg.data;\n }\n}\n"},"src/contracts/vendored/libraries/Counters.sol":{"content":"// SPDX-License-Identifier: MIT\n\n// Vendored from OpenZeppelin Contracts v4.4.0, see:\n// \n\n// OpenZeppelin Contracts v4.4.0 (utils/Counters.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @title Counters\n * @author Matt Condon (@shrugs)\n * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\n *\n * Include with `using Counters for Counters.Counter;`\n */\nlibrary Counters {\n struct Counter {\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\n // this feature: see https://github.com/ethereum/solidity/issues/4637\n uint256 _value; // default: 0\n }\n\n function current(Counter storage counter) internal view returns (uint256) {\n return counter._value;\n }\n\n function increment(Counter storage counter) internal {\n unchecked {\n counter._value += 1;\n }\n }\n\n function decrement(Counter storage counter) internal {\n uint256 value = counter._value;\n require(value > 0, \"Counter: decrement overflow\");\n unchecked {\n counter._value = value - 1;\n }\n }\n\n function reset(Counter storage counter) internal {\n counter._value = 0;\n }\n}\n"},"src/contracts/vendored/mixins/draft-EIP712.sol":{"content":"// SPDX-License-Identifier: MIT\n\n// Vendored from OpenZeppelin Contracts v4.4.0, see:\n// \n// The following changes were made:\n// - Vendored imports\n\n// OpenZeppelin Contracts v4.4.0 (utils/cryptography/draft-EIP712.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../libraries/ECDSA.sol\";\n\n/**\n * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.\n *\n * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,\n * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding\n * they need in their contracts using a combination of `abi.encode` and `keccak256`.\n *\n * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding\n * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA\n * ({_hashTypedDataV4}).\n *\n * The implementation of the domain separator was designed to be as efficient as possible while still properly updating\n * the chain id to protect against replay attacks on an eventual fork of the chain.\n *\n * NOTE: This contract implements the version of the encoding known as \"v4\", as implemented by the JSON RPC method\n * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].\n *\n * _Available since v3.4._\n */\nabstract contract EIP712 {\n /* solhint-disable var-name-mixedcase */\n // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to\n // 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 address private immutable _CACHED_THIS;\n\n bytes32 private immutable _HASHED_NAME;\n bytes32 private immutable _HASHED_VERSION;\n bytes32 private immutable _TYPE_HASH;\n\n /* solhint-enable var-name-mixedcase */\n\n /**\n * @dev Initializes the domain separator and parameter caches.\n *\n * The meaning of `name` and `version` is specified in\n * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:\n *\n * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.\n * - `version`: the current major version of the signing domain.\n *\n * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart\n * contract upgrade].\n */\n constructor(string memory name, string memory version) {\n bytes32 hashedName = keccak256(bytes(name));\n bytes32 hashedVersion = keccak256(bytes(version));\n bytes32 typeHash = keccak256(\n \"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\"\n );\n _HASHED_NAME = hashedName;\n _HASHED_VERSION = hashedVersion;\n _CACHED_CHAIN_ID = block.chainid;\n _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(\n typeHash,\n hashedName,\n hashedVersion\n );\n _CACHED_THIS = address(this);\n _TYPE_HASH = typeHash;\n }\n\n /**\n * @dev Returns the domain separator for the current chain.\n */\n function _domainSeparatorV4() internal view returns (bytes32) {\n if (\n address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID\n ) {\n return _CACHED_DOMAIN_SEPARATOR;\n } else {\n return\n _buildDomainSeparator(\n _TYPE_HASH,\n _HASHED_NAME,\n _HASHED_VERSION\n );\n }\n }\n\n function _buildDomainSeparator(\n bytes32 typeHash,\n bytes32 nameHash,\n bytes32 versionHash\n ) private view returns (bytes32) {\n return\n keccak256(\n abi.encode(\n typeHash,\n nameHash,\n versionHash,\n block.chainid,\n address(this)\n )\n );\n }\n\n /**\n * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this\n * function returns the hash of the fully encoded EIP712 message for this domain.\n *\n * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:\n *\n * ```solidity\n * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(\n * keccak256(\"Mail(address to,string contents)\"),\n * mailTo,\n * keccak256(bytes(mailContents))\n * )));\n * address signer = ECDSA.recover(digest, signature);\n * ```\n */\n function _hashTypedDataV4(bytes32 structHash)\n internal\n view\n virtual\n returns (bytes32)\n {\n return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);\n }\n}\n"},"src/contracts/vendored/mixins/StorageAccessible.sol":{"content":"// SPDX-License-Identifier: LGPL-3.0-only\n\n// Vendored from Gnosis utility contracts, see:\n// \n// The following changes were made:\n// - Modified Solidity version\n// - Formatted code\n\npragma solidity ^0.8.10;\n\n/// @title ViewStorageAccessible - Interface on top of StorageAccessible base class to allow simulations from view functions\ninterface ViewStorageAccessible {\n /**\n * @dev Same as `simulateDelegatecall` on StorageAccessible. Marked as view so that it can be called from external contracts\n * that want to run simulations from within view functions. Will revert if the invoked simulation attempts to change state.\n */\n function simulateDelegatecall(\n address targetContract,\n bytes memory calldataPayload\n ) external view returns (bytes memory);\n\n /**\n * @dev Same as `getStorageAt` on StorageAccessible. This method allows reading aribtrary ranges of storage.\n */\n function getStorageAt(uint256 offset, uint256 length)\n external\n view\n returns (bytes memory);\n}\n\n/// @title StorageAccessible - generic base contract that allows callers to access all internal storage.\ncontract StorageAccessible {\n /**\n * @dev Reads `length` bytes of storage in the currents contract\n * @param offset - the offset in the current contract's storage in words to start reading from\n * @param length - the number of words (32 bytes) of data to read\n * @return the bytes that were read.\n */\n function getStorageAt(uint256 offset, uint256 length)\n external\n view\n returns (bytes memory)\n {\n bytes memory result = new bytes(length * 32);\n for (uint256 index = 0; index < length; index++) {\n // solhint-disable-next-line no-inline-assembly\n assembly {\n let word := sload(add(offset, index))\n mstore(add(add(result, 0x20), mul(index, 0x20)), word)\n }\n }\n return result;\n }\n\n /**\n * @dev Performs a delegetecall on a targetContract in the context of self.\n * Internally reverts execution to avoid side effects (making it static). Catches revert and returns encoded result as bytes.\n * @param targetContract Address of the contract containing the code to execute.\n * @param calldataPayload Calldata that should be sent to the target contract (encoded method name and arguments).\n */\n function simulateDelegatecall(\n address targetContract,\n bytes memory calldataPayload\n ) public returns (bytes memory response) {\n bytes memory innerCall = abi.encodeWithSelector(\n this.simulateDelegatecallInternal.selector,\n targetContract,\n calldataPayload\n );\n // solhint-disable-next-line avoid-low-level-calls\n (, response) = address(this).call(innerCall);\n bool innerSuccess = response[response.length - 1] == 0x01;\n setLength(response, response.length - 1);\n if (innerSuccess) {\n return response;\n } else {\n revertWith(response);\n }\n }\n\n /**\n * @dev Performs a delegetecall on a targetContract in the context of self.\n * Internally reverts execution to avoid side effects (making it static). Returns encoded result as revert message\n * concatenated with the success flag of the inner call as a last byte.\n * @param targetContract Address of the contract containing the code to execute.\n * @param calldataPayload Calldata that should be sent to the target contract (encoded method name and arguments).\n */\n function simulateDelegatecallInternal(\n address targetContract,\n bytes memory calldataPayload\n ) external returns (bytes memory response) {\n bool success;\n // solhint-disable-next-line avoid-low-level-calls\n (success, response) = targetContract.delegatecall(calldataPayload);\n revertWith(abi.encodePacked(response, success));\n }\n\n function revertWith(bytes memory response) internal pure {\n // solhint-disable-next-line no-inline-assembly\n assembly {\n revert(add(response, 0x20), mload(response))\n }\n }\n\n function setLength(bytes memory buffer, uint256 length) internal pure {\n // solhint-disable-next-line no-inline-assembly\n assembly {\n mstore(buffer, length)\n }\n }\n}\n"},"src/contracts/vendored/mixins/draft-ERC20Permit.sol":{"content":"// SPDX-License-Identifier: MIT\n\n// Vendored from OpenZeppelin Contracts v4.4.0, see:\n// \n// The following changes were made:\n// - Vendored imports\n\n// OpenZeppelin Contracts v4.4.0 (token/ERC20/extensions/draft-ERC20Permit.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../interfaces/draft-IERC20Permit.sol\";\nimport \"./ERC20.sol\";\nimport \"./draft-EIP712.sol\";\nimport \"../libraries/ECDSA.sol\";\nimport \"../libraries/Counters.sol\";\n\n/**\n * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n *\n * _Available since v3.4._\n */\nabstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {\n using Counters for Counters.Counter;\n\n mapping(address => Counters.Counter) private _nonces;\n\n // solhint-disable-next-line var-name-mixedcase\n bytes32 private immutable _PERMIT_TYPEHASH =\n keccak256(\n \"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\"\n );\n\n /**\n * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `\"1\"`.\n *\n * It's a good idea to use the same `name` that is defined as the ERC20 token name.\n */\n constructor(string memory name) EIP712(name, \"1\") {}\n\n /**\n * @dev See {IERC20Permit-permit}.\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 override {\n require(block.timestamp <= deadline, \"ERC20Permit: expired deadline\");\n\n bytes32 structHash = keccak256(\n abi.encode(\n _PERMIT_TYPEHASH,\n owner,\n spender,\n value,\n _useNonce(owner),\n deadline\n )\n );\n\n bytes32 hash = _hashTypedDataV4(structHash);\n\n address signer = ECDSA.recover(hash, v, r, s);\n require(signer == owner, \"ERC20Permit: invalid signature\");\n\n _approve(owner, spender, value);\n }\n\n /**\n * @dev See {IERC20Permit-nonces}.\n */\n function nonces(address owner)\n public\n view\n virtual\n override\n returns (uint256)\n {\n return _nonces[owner].current();\n }\n\n /**\n * @dev See {IERC20Permit-DOMAIN_SEPARATOR}.\n */\n // solhint-disable-next-line func-name-mixedcase\n function DOMAIN_SEPARATOR() external view override returns (bytes32) {\n return _domainSeparatorV4();\n }\n\n /**\n * @dev \"Consume a nonce\": return the current value and increment.\n *\n * _Available since v4.1._\n */\n function _useNonce(address owner)\n internal\n virtual\n returns (uint256 current)\n {\n Counters.Counter storage nonce = _nonces[owner];\n current = nonce.current();\n nonce.increment();\n }\n}\n"},"src/contracts/vendored/interfaces/IERC20Metadata.sol":{"content":"// SPDX-License-Identifier: MIT\n\n// Vendored from OpenZeppelin Contracts v4.4.0, see:\n// \n// The following changes were made:\n// - Vendored imports\n\n// OpenZeppelin Contracts v4.4.0 (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20Metadata is IERC20 {\n /**\n * @dev Returns the name of the token.\n */\n function name() external view returns (string memory);\n\n /**\n * @dev Returns the symbol of the token.\n */\n function symbol() external view returns (string memory);\n\n /**\n * @dev Returns the decimals places of the token.\n */\n function decimals() external view returns (uint8);\n}\n"},"src/contracts/vendored/interfaces/draft-IERC20Permit.sol":{"content":"// SPDX-License-Identifier: MIT\n\n// Vendored from OpenZeppelin Contracts v4.4.0, see:\n// \n\n// OpenZeppelin Contracts v4.4.0 (token/ERC20/extensions/draft-IERC20Permit.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n */\ninterface IERC20Permit {\n /**\n * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\n * given ``owner``'s signed approval.\n *\n * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n * ordering also apply here.\n *\n * Emits an {Approval} event.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n * - `deadline` must be a timestamp in the future.\n * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n * over the EIP712-formatted function arguments.\n * - the signature must use ``owner``'s current nonce (see {nonces}).\n *\n * For more information on the signature format, see the\n * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n * section].\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 ) external;\n\n /**\n * @dev Returns the current nonce for `owner`. This value must be\n * included whenever a signature is generated for {permit}.\n *\n * Every successful call to {permit} increases ``owner``'s nonce by one. This\n * prevents a signature from being used multiple times.\n */\n function nonces(address owner) external view returns (uint256);\n\n /**\n * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\n */\n // solhint-disable-next-line func-name-mixedcase\n function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.10+commit.fc410830","compilerSettings":{"metadata":{"bytecodeHash":"ipfs"},"libraries":{},"optimizer":{"runs":1000000,"enabled":true},"evmVersion":"london","remappings":[]},"name":"CowProtocolToken","fullyQualifiedName":"src/contracts/CowProtocolToken.sol:CowProtocolToken"},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"293:519:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2383:98:9;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4604:202;;;;;;:::i;:::-;;:::i;:::-;;;1449:14:13;;1442:22;1424:41;;1412:2;1397:18;4604:202:9;1284:187:13;3471:106:9;3558:12;;3471:106;;;1622:25:13;;;1610:2;1595:18;3471:106:9;1476:177:13;5273:512:9;;;;;;:::i;:::-;;:::i;3320:91::-;;;3402:2;2133:36:13;;2121:2;2106:18;3320:91:9;1991:184:13;2922:113:12;;;:::i;6180:286:9:-;;;;;;:::i;:::-;;:::i;1844:491:1:-;;;;;;:::i;:::-;;:::i;:::-;;3728:376:10;;;;;;:::i;:::-;;:::i;1617:494::-;;;;;;:::i;:::-;;:::i;642:48:1:-;;689:1;642:48;;3635:169:9;;;;;;:::i;:::-;3779:18;;3749:7;3779:18;;;;;;;;;;;;3635:169;2628:170:12;;;;;;:::i;:::-;;:::i;2594:102:9:-;;;:::i;6953:467::-;;;;;;:::i;:::-;;:::i;4007:208::-;;;;;;:::i;:::-;;:::i;528:56:1:-;;576:8;528:56;;1809:758:12;;;;;;:::i;:::-;;:::i;4273:193:9:-;;;;;;:::i;:::-;4432:18;;;;4402:7;4432:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;4273:193;415:31:1;;;;;;;;5416:42:13;5404:55;;;5386:74;;5374:2;5359:18;415:31:1;5240:226:13;2547:680:10;;;;;;:::i;:::-;;:::i;758:39:1:-;;;;;;2383:98:9;2437:13;2469:5;2462:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2383:98;:::o;4604:202::-;4719:4;4739:39;884:10:2;4762:7:9;4771:6;4739:8;:39::i;:::-;-1:-1:-1;4795:4:9;4604:202;;;;;:::o;5273:512::-;5409:4;5425:36;5435:6;5443:9;5454:6;5425:9;:36::i;:::-;5499:19;;;5472:24;5499:19;;;:11;:19;;;;;;;;884:10:2;5499:33:9;;;;;;;;5563:26;;;;5542:113;;;;;;;6115:2:13;5542:113:9;;;6097:21:13;6154:2;6134:18;;;6127:30;6193:34;6173:18;;;6166:62;6264:10;6244:18;;;6237:38;6292:19;;5542:113:9;;;;;;;;;5689:57;5698:6;884:10:2;5739:6:9;5720:16;:25;5689:8;:57::i;:::-;-1:-1:-1;5774:4:9;;5273:512;-1:-1:-1;;;;5273:512:9:o;2922:113:12:-;2982:7;3008:20;:18;:20::i;:::-;3001:27;;2922:113;:::o;6180:286:9:-;884:10:2;6292:4:9;6381:25;;;:11;:25;;;;;;;;;:34;;;;;;;;;;6292:4;;6312:126;;6360:7;;6381:47;;6418:10;;6381:47;:::i;:::-;6312:8;:126::i;1844:491:1:-;1158:10;:20;1172:6;1158:20;;1154:70;;1201:12;;;;;;;;;;;;;;1154:70;1974:3:::1;689:1;1934:13;3558:12:9::0;;;3471:106;1934:13:1::1;:36;;;;:::i;:::-;1933:44;;;;:::i;:::-;1924:6;:53;1920:109;;;2000:18;;;;;;;;;;;;;;1920:109;2143:15;576:8;2096:20;;:44;;;;:::i;:::-;:62;2092:117;;;2181:17;;;;;;;;;;;;;;2092:117;2241:15;2218:20;:38:::0;2307:21:::1;2313:6:::0;2321;2307:5:::1;:21::i;:::-;1844:491:::0;;:::o;3728:376:10:-;3860:21;3893:12;3996:14;:27;;4024:15;3996:44;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4061:35:10;;3974:66;;-1:-1:-1;3974:66:10;;-1:-1:-1;4050:47:10;;4061:35;;3974:66;;;;4061:35;;;:::i;:::-;;;;;;;;;;;;;4050:10;:47::i;:::-;3883:221;3728:376;;;;:::o;1617:494::-;1718:12;1746:19;1778:11;:6;1787:2;1778:11;:::i;:::-;1768:22;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1768:22:10;;1746:44;;1805:13;1800:282;1832:6;1824:5;:14;1800:282;;;1968:18;;;1962:25;2045:4;2034:16;;;2011:40;;;2004:54;1980:5;1840:7;1980:5;1840:7;:::i;:::-;;;;1800:282;;;-1:-1:-1;2098:6:10;1617:494;-1:-1:-1;;;1617:494:10:o;2628:170:12:-;2767:14;;;2737:7;2767:14;;;:7;:14;;;;;1084::6;2767:24:12;993:112:6;2594:102:9;2650:13;2682:7;2675:14;;;;;:::i;6953:467::-;884:10:2;7070:4:9;7117:25;;;:11;:25;;;;;;;;;:34;;;;;;;;;;7182:35;;;;7161:119;;;;;;;8229:2:13;7161:119:9;;;8211:21:13;8268:2;8248:18;;;8241:30;8307:34;8287:18;;;8280:62;8378:7;8358:18;;;8351:35;8403:19;;7161:119:9;8027:401:13;7161:119:9;7314:67;884:10:2;7337:7:9;7365:15;7346:16;:34;7314:8;:67::i;:::-;-1:-1:-1;7409:4:9;;6953:467;-1:-1:-1;;;6953:467:9:o;4007:208::-;4125:4;4145:42;884:10:2;4169:9:9;4180:6;4145:9;:42::i;1809:758:12:-;2044:8;2025:15;:27;;2017:69;;;;;;;8635:2:13;2017:69:12;;;8617:21:13;8674:2;8654:18;;;8647:30;8713:31;8693:18;;;8686:59;8762:18;;2017:69:12;8433:353:13;2017:69:12;2097:18;2169:16;2203:5;2226:7;2251:5;2274:16;2284:5;2274:9;:16::i;:::-;2141:189;;;;;;9078:25:13;;;;9122:42;9200:15;;;9180:18;;;9173:43;9252:15;;;;9232:18;;;9225:43;9284:18;;;9277:34;9327:19;;;9320:35;9371:19;;;9364:35;;;9050:19;;2141:189:12;;;;;;;;;;;;2118:222;;;;;;2097:243;;2351:12;2366:28;2383:10;2366:16;:28::i;:::-;2351:43;;2405:14;2422:28;2436:4;2442:1;2445;2448;2422:13;:28::i;:::-;2405:45;;2478:5;2468:15;;:6;:15;;;2460:58;;;;;;;9612:2:13;2460:58:12;;;9594:21:13;9651:2;9631:18;;;9624:30;9690:32;9670:18;;;9663:60;9740:18;;2460:58:12;9410:354:13;2460:58:12;2529:31;2538:5;2545:7;2554:5;2529:8;:31::i;:::-;2007:560;;;1809:758;;;;;;;:::o;2547:680:10:-;2669:21;2702:22;2763:42;;;2819:14;2847:15;2727:145;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2956:29;;2727:145;;-1:-1:-1;2964:4:10;;2956:29;;2727:145;;2956:29;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2941:44;;;;;;2995:17;3015:8;3042:1;3024:8;:15;:19;;;;:::i;:::-;3015:29;;;;;;;;:::i;:::-;;;;;;;;;:37;;;3048:4;3015:37;;;2995:57;;3062:40;3072:8;3100:1;3082:8;:15;:19;;;;:::i;:::-;4481:22;;4322:197;3062:40;3116:12;3112:109;;;3144:15;;;;3112:109;3190:20;3201:8;3190:10;:20::i;:::-;2692:535;;2547:680;;;;:::o;10625:370:9:-;10756:19;;;10748:68;;;;;;;10633:2:13;10748:68:9;;;10615:21:13;10672:2;10652:18;;;10645:30;10711:34;10691:18;;;10684:62;10782:6;10762:18;;;10755:34;10806:19;;10748:68:9;10431:400:13;10748:68:9;10834:21;;;10826:68;;;;;;;11038:2:13;10826:68:9;;;11020:21:13;11077:2;11057:18;;;11050:30;11116:34;11096:18;;;11089:62;11187:4;11167:18;;;11160:32;11209:19;;10826:68:9;10836:398:13;10826:68:9;10905:18;;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;10956:32;;1622:25:13;;;10956:32:9;;1595:18:13;10956:32:9;;;;;;;10625:370;;;:::o;7894:747::-;8029:20;;;8021:70;;;;;;;11441:2:13;8021:70:9;;;11423:21:13;11480:2;11460:18;;;11453:30;11519:34;11499:18;;;11492:62;11590:7;11570:18;;;11563:35;11615:19;;8021:70:9;11239:401:13;8021:70:9;8109:23;;;8101:71;;;;;;;11847:2:13;8101:71:9;;;11829:21:13;11886:2;11866:18;;;11859:30;11925:34;11905:18;;;11898:62;11996:5;11976:18;;;11969:33;12019:19;;8101:71:9;11645:399:13;8101:71:9;8265:17;;;8241:21;8265:17;;;;;;;;;;;8313:23;;;;8292:108;;;;;;;12251:2:13;8292:108:9;;;12233:21:13;12290:2;12270:18;;;12263:30;12329:34;12309:18;;;12302:62;12400:8;12380:18;;;12373:36;12426:19;;8292:108:9;12049:402:13;8292:108:9;8434:17;;;;:9;:17;;;;;;;;;;;8454:22;;;8434:42;;8496:20;;;;;;;;:30;;8470:6;;8434:9;8496:30;;8470:6;;8496:30;:::i;:::-;;;;;;;;8559:9;8542:35;;8551:6;8542:35;;;8570:6;8542:35;;;;1622:25:13;;1610:2;1595:18;;1476:177;8542:35:9;;;;;;;;8588:46;8011:630;7894:747;;;:::o;3441:424:11:-;3494:7;3538:4;3530:29;3547:12;3530:29;;:66;;;;;3580:16;3563:13;:33;3530:66;3513:346;;;-1:-1:-1;3628:24:11;;3441:424::o;3513:346::-;-1:-1:-1;4076:191:11;;;3749:10;4076:191;;;;13075:25:13;;;;3781:12:11;13116:18:13;;;13109:34;3815:15:11;13159:18:13;;;13152:34;4201:13:11;13202:18:13;;;13195:34;4244:4:11;13245:19:13;;;;13238:84;;;;4076:191:11;;;;;;;;;;13047:19:13;;;;4076:191:11;;;4049:232;;;;;;2922:113:12:o;8917:389:9:-;9000:21;;;8992:65;;;;;;;12658:2:13;8992:65:9;;;12640:21:13;12697:2;12677:18;;;12670:30;12736:33;12716:18;;;12709:61;12787:18;;8992:65:9;12456:355:13;8992:65:9;9144:6;9128:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;9160:18:9;;;:9;:18;;;;;;;;;;:28;;9182:6;;9160:9;:28;;9182:6;;9160:28;:::i;:::-;;;;-1:-1:-1;;9203:37:9;;1622:25:13;;;9203:37:9;;;;9220:1;;9203:37;;1610:2:13;1595:18;9203:37:9;;;;;;;1844:491:1;;:::o;4110:206:10:-;4290:8;4284:15;4277:4;4267:8;4263:19;4256:44;3166:231:12;3314:14;;;3250:15;3314:14;;;:7;:14;;;;;1084::6;;1216:1;1198:19;;;;1084:14;3373:17:12;3271:126;3166:231;;;:::o;4913:201:11:-;5022:7;5052:55;5074:20;:18;:20::i;:::-;5096:10;9898:57:7;;13603:66:13;9898:57:7;;;13591:79:13;13686:11;;;13679:27;;;13722:12;;;13715:28;;;9829:7:7;;13759:12:13;;9898:57:7;;;;;;;;;;;;9871:98;;;;;;9852:117;;9712:264;;;;;7849:270;7972:7;7992:17;8011:18;8033:25;8044:4;8050:1;8053;8056;8033:10;:25::i;:::-;7991:67;;;;8068:18;8080:5;8068:11;:18::i;:::-;-1:-1:-1;8103:9:7;7849:270;-1:-1:-1;;;;;7849:270:7:o;6079:1637::-;6205:7;;7154:66;7129:91;;7112:195;;;-1:-1:-1;7261:1:7;;-1:-1:-1;7265:30:7;7245:51;;7112:195;7320:1;:7;;7325:2;7320:7;;:18;;;;;7331:1;:7;;7336:2;7331:7;;7320:18;7316:100;;;-1:-1:-1;7370:1:7;;-1:-1:-1;7374:30:7;7354:51;;7316:100;7527:24;;;7510:14;7527:24;;;;;;;;;14009:25:13;;;14082:4;14070:17;;14050:18;;;14043:45;;;;14104:18;;;14097:34;;;14147:18;;;14140:34;;;7527:24:7;;13981:19:13;;7527:24:7;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;7527:24:7;;;;;;-1:-1:-1;;7565:20:7;;;7561:101;;7617:1;7621:29;7601:50;;;;;;;7561:101;7680:6;-1:-1:-1;7688:20:7;;-1:-1:-1;6079:1637:7;;;;;;;;:::o;766:631::-;843:20;834:5;:29;;;;;;;;:::i;:::-;;830:561;;;766:631;:::o;830:561::-;939:29;930:5;:38;;;;;;;;:::i;:::-;;926:465;;;984:34;;;;;14576:2:13;984:34:7;;;14558:21:13;14615:2;14595:18;;;14588:30;14654:26;14634:18;;;14627:54;14698:18;;984:34:7;14374:348:13;926:465:7;1048:35;1039:5;:44;;;;;;;;:::i;:::-;;1035:356;;;1099:41;;;;;14929:2:13;1099:41:7;;;14911:21:13;14968:2;14948:18;;;14941:30;15007:33;14987:18;;;14980:61;15058:18;;1099:41:7;14727:355:13;1035:356:7;1170:30;1161:5;:39;;;;;;;;:::i;:::-;;1157:234;;;1216:44;;;;;15289:2:13;1216:44:7;;;15271:21:13;15328:2;15308:18;;;15301:30;15367:34;15347:18;;;15340:62;15438:4;15418:18;;;15411:32;15460:19;;1216:44:7;15087:398:13;1157:234:7;1290:30;1281:5;:39;;;;;;;;:::i;:::-;;1277:114;;;1336:44;;;;;15692:2:13;1336:44:7;;;15674:21:13;15731:2;15711:18;;;15704:30;15770:34;15750:18;;;15743:62;15841:4;15821:18;;;15814:32;15863:19;;1336:44:7;15490:398:13;1277:114:7;766:631;:::o;14:258:13:-;86:1;96:113;110:6;107:1;104:13;96:113;;;186:11;;;180:18;167:11;;;160:39;132:2;125:10;96:113;;;227:6;224:1;221:13;218:48;;;-1:-1:-1;;262:1:13;244:16;;237:27;14:258::o;277:317::-;319:3;357:5;351:12;384:6;379:3;372:19;400:63;456:6;449:4;444:3;440:14;433:4;426:5;422:16;400:63;:::i;:::-;508:2;496:15;513:66;492:88;483:98;;;;583:4;479:109;;277:317;-1:-1:-1;;277:317:13:o;599:220::-;748:2;737:9;730:21;711:4;768:45;809:2;798:9;794:18;786:6;768:45;:::i;:::-;760:53;599:220;-1:-1:-1;;;599:220:13:o;824:196::-;892:20;;952:42;941:54;;931:65;;921:93;;1010:1;1007;1000:12;921:93;824:196;;;:::o;1025:254::-;1093:6;1101;1154:2;1142:9;1133:7;1129:23;1125:32;1122:52;;;1170:1;1167;1160:12;1122:52;1193:29;1212:9;1193:29;:::i;:::-;1183:39;1269:2;1254:18;;;;1241:32;;-1:-1:-1;;;1025:254:13:o;1658:328::-;1735:6;1743;1751;1804:2;1792:9;1783:7;1779:23;1775:32;1772:52;;;1820:1;1817;1810:12;1772:52;1843:29;1862:9;1843:29;:::i;:::-;1833:39;;1891:38;1925:2;1914:9;1910:18;1891:38;:::i;:::-;1881:48;;1976:2;1965:9;1961:18;1948:32;1938:42;;1658:328;;;;;:::o;2362:184::-;2414:77;2411:1;2404:88;2511:4;2508:1;2501:15;2535:4;2532:1;2525:15;2551:1054;2628:6;2636;2689:2;2677:9;2668:7;2664:23;2660:32;2657:52;;;2705:1;2702;2695:12;2657:52;2728:29;2747:9;2728:29;:::i;:::-;2718:39;;2808:2;2797:9;2793:18;2780:32;2831:18;2872:2;2864:6;2861:14;2858:34;;;2888:1;2885;2878:12;2858:34;2926:6;2915:9;2911:22;2901:32;;2971:7;2964:4;2960:2;2956:13;2952:27;2942:55;;2993:1;2990;2983:12;2942:55;3029:2;3016:16;3051:2;3047;3044:10;3041:36;;;3057:18;;:::i;:::-;3191:2;3185:9;3253:4;3245:13;;3096:66;3241:22;;;3265:2;3237:31;3233:40;3221:53;;;3289:18;;;3309:22;;;3286:46;3283:72;;;3335:18;;:::i;:::-;3375:10;3371:2;3364:22;3410:2;3402:6;3395:18;3450:7;3445:2;3440;3436;3432:11;3428:20;3425:33;3422:53;;;3471:1;3468;3461:12;3422:53;3527:2;3522;3518;3514:11;3509:2;3501:6;3497:15;3484:46;3572:1;3567:2;3562;3554:6;3550:15;3546:24;3539:35;3593:6;3583:16;;;;;;;2551:1054;;;;;:::o;3833:248::-;3901:6;3909;3962:2;3950:9;3941:7;3937:23;3933:32;3930:52;;;3978:1;3975;3968:12;3930:52;-1:-1:-1;;4001:23:13;;;4071:2;4056:18;;;4043:32;;-1:-1:-1;3833:248:13:o;4086:186::-;4145:6;4198:2;4186:9;4177:7;4173:23;4169:32;4166:52;;;4214:1;4211;4204:12;4166:52;4237:29;4256:9;4237:29;:::i;4277:693::-;4388:6;4396;4404;4412;4420;4428;4436;4489:3;4477:9;4468:7;4464:23;4460:33;4457:53;;;4506:1;4503;4496:12;4457:53;4529:29;4548:9;4529:29;:::i;:::-;4519:39;;4577:38;4611:2;4600:9;4596:18;4577:38;:::i;:::-;4567:48;;4662:2;4651:9;4647:18;4634:32;4624:42;;4713:2;4702:9;4698:18;4685:32;4675:42;;4767:3;4756:9;4752:19;4739:33;4812:4;4805:5;4801:16;4794:5;4791:27;4781:55;;4832:1;4829;4822:12;4781:55;4277:693;;;;-1:-1:-1;4277:693:13;;;;4855:5;4907:3;4892:19;;4879:33;;-1:-1:-1;4959:3:13;4944:19;;;4931:33;;4277:693;-1:-1:-1;;4277:693:13:o;4975:260::-;5043:6;5051;5104:2;5092:9;5083:7;5079:23;5075:32;5072:52;;;5120:1;5117;5110:12;5072:52;5143:29;5162:9;5143:29;:::i;:::-;5133:39;;5191:38;5225:2;5214:9;5210:18;5191:38;:::i;:::-;5181:48;;4975:260;;;;;:::o;5471:437::-;5550:1;5546:12;;;;5593;;;5614:61;;5668:4;5660:6;5656:17;5646:27;;5614:61;5721:2;5713:6;5710:14;5690:18;5687:38;5684:218;;;5758:77;5755:1;5748:88;5859:4;5856:1;5849:15;5887:4;5884:1;5877:15;6322:184;6374:77;6371:1;6364:88;6471:4;6468:1;6461:15;6495:4;6492:1;6485:15;6511:128;6551:3;6582:1;6578:6;6575:1;6572:13;6569:39;;;6588:18;;:::i;:::-;-1:-1:-1;6624:9:13;;6511:128::o;6644:228::-;6684:7;6810:1;6742:66;6738:74;6735:1;6732:81;6727:1;6720:9;6713:17;6709:105;6706:131;;;6817:18;;:::i;:::-;-1:-1:-1;6857:9:13;;6644:228::o;6877:274::-;6917:1;6943;6933:189;;6978:77;6975:1;6968:88;7079:4;7076:1;7069:15;7107:4;7104:1;7097:15;6933:189;-1:-1:-1;7136:9:13;;6877:274::o;7156:::-;7285:3;7323:6;7317:13;7339:53;7385:6;7380:3;7373:4;7365:6;7361:17;7339:53;:::i;:::-;7408:16;;;;;7156:274;-1:-1:-1;;7156:274:13:o;7435:387::-;7586:3;7624:6;7618:13;7640:53;7686:6;7681:3;7674:4;7666:6;7662:17;7640:53;:::i;:::-;7770:14;;7763:22;7758:3;7754:32;7715:16;;;;7740:47;;;7814:1;7803:13;;7435:387;-1:-1:-1;;7435:387:13:o;7827:195::-;7866:3;7897:66;7890:5;7887:77;7884:103;;;7967:18;;:::i;:::-;-1:-1:-1;8014:1:13;8003:13;;7827:195::o;9769:338::-;9956:42;9948:6;9944:55;9933:9;9926:74;10036:2;10031;10020:9;10016:18;10009:30;9907:4;10056:45;10097:2;10086:9;10082:18;10074:6;10056:45;:::i;:::-;10048:53;9769:338;-1:-1:-1;;;;9769:338:13:o;10112:125::-;10152:4;10180:1;10177;10174:8;10171:34;;;10185:18;;:::i;:::-;-1:-1:-1;10222:9:13;;10112:125::o;10242:184::-;10294:77;10291:1;10284:88;10391:4;10388:1;10381:15;10415:4;10412:1;10405:15;14185:184;14237:77;14234:1;14227:88;14334:4;14331:1;14324:15;14358:4;14355:1;14348:15","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220530954a1b40a0e3c6d45330c16c5bf384a847ba06bf8ebbb9afdfb09ada68c0b64736f6c634300080a0033","offset":7292}},"immutableReferences":{"44":[{"start":826,"length":32},{"start":1441,"length":32}],"1710":[{"start":4364,"length":32}],"1712":[{"start":4322,"length":32}],"1714":[{"start":4280,"length":32}],"1716":[{"start":4447,"length":32}],"1718":[{"start":4484,"length":32}],"1720":[{"start":4405,"length":32}],"1886":[{"start":2404,"length":32}]},"transformations":[{"id":"44","type":"replace","offset":826,"reason":"immutable"},{"id":"44","type":"replace","offset":1441,"reason":"immutable"},{"id":"1710","type":"replace","offset":4364,"reason":"immutable"},{"id":"1712","type":"replace","offset":4322,"reason":"immutable"},{"id":"1714","type":"replace","offset":4280,"reason":"immutable"},{"id":"1716","type":"replace","offset":4447,"reason":"immutable"},{"id":"1718","type":"replace","offset":4484,"reason":"immutable"},{"id":"1720","type":"replace","offset":4405,"reason":"immutable"},{"id":"1886","type":"replace","offset":2404,"reason":"immutable"}],"transformationValues":{"immutables":{"44":"0x000000000000000000000000ca771eda0c70aa7d053ab1b25004559b918fe662","1710":"0x82b58cb6c4763c2e16f6ab9b7f31298f8c336f40e20275bee4874eaef35b26a7","1712":"0x0000000000000000000000000000000000000000000000000000000000000001","1714":"0x000000000000000000000000def1ca1fb7fbcdc777520aa7f396b4e015f497ab","1716":"0xfa06afcd6864e6018b77d7e56546b65c51c53696e01173b710c745b9c2415405","1718":"0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6","1720":"0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f","1886":"0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9"}}},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"deployment":{"transactionHash":"0x39d9737ec1241ae892b726b962e7c9103a8048398c4e3b3b36cb9adb8e457a13","blockNumber":"14186722","transactionIndex":"155","deployer":"0x5D06F06A61271aA38Af23D1D2422212c9bE83940"},"matchId":"2075995","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2024-08-08T14:31:37Z","match":"exact_match","chainId":"1","address":"0xDEf1CA1fb7FBcDC777520aa7f396b4E015F497aB"}