From 3ac0668a4e8a0bebb355096c94f7b9073bf68b83 Mon Sep 17 00:00:00 2001 From: elshan_eth Date: Tue, 27 Feb 2024 18:43:25 +0100 Subject: [PATCH] create test env --- contracts/deploy-mainnet/0004_DevReward.ts | 81 +++---------------- .../sepolia/DevRewardDistributor.json | 30 +++---- web/src/constants/addresses.js | 2 +- 3 files changed, 26 insertions(+), 87 deletions(-) diff --git a/contracts/deploy-mainnet/0004_DevReward.ts b/contracts/deploy-mainnet/0004_DevReward.ts index d49c3ce..8302245 100644 --- a/contracts/deploy-mainnet/0004_DevReward.ts +++ b/contracts/deploy-mainnet/0004_DevReward.ts @@ -1,7 +1,7 @@ import { HardhatRuntimeEnvironment } from "hardhat/types"; import { DeployFunction } from "hardhat-deploy/types"; import "hardhat-deploy"; -import { HOURS, MINUTES } from "../utils/time"; +import { MINUTES, MONTH } from "../utils/time"; import { ethers } from "hardhat"; const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) { @@ -14,81 +14,20 @@ const func: DeployFunction = async function (hre: HardhatRuntimeEnvironment) { from: deployer, contract: "DevRewardDistributor", args: [ - token.address, - deployer, - "0x82e1cd2ef5365e6db5b707763079758302a04bb39e2b5199f460fc316b74890a", - 2 * HOURS, - 10 * MINUTES, - ethers.utils.parseEther("1000"), - 20 * HOURS, - deployer, - ethers.utils.parseEther("1000000000"), + token.address, // _token + deployer, // executor + "0x9054c3420799d2857b3706ca310823473c3b76dd666412134952aeba279e888a", + 30 * MINUTES, // harvestPeriod + 5 * MINUTES, // _lockupPeriod + ethers.utils.parseEther("5000"), // initialReward + 12 * MONTH, // claimPeriod + deployer, // cenceler + ethers.utils.parseEther("50000000"), // maxClaimedSupply ], waitConfirmations: 1, }); console.log(`DevRewardDistributor deployed to ${deployResult.address}\n`); - - // const teamVestingResult = await hre.deployments.deploy("TeamVesting", { - // from: deployer, - // contract: "VestingWithVoting", - // args: [ - // token.address, - // "Fluence Token (Locked, Voting)", - // "FLT-LV #666", - // 20 * HOURS, - // 20 * HOURS, - // [ - // "0x198691769280d07706a9c85B30565E928F8A9025", - // "0x074e67fF7cE5A91055E42AdA692289aE2225Be06", - // ], - // [ - // ethers.utils.parseEther("100000000"), - // ethers.utils.parseEther("100000000"), - // ], - // ], - // waitConfirmations: 1, - // }); - - // console.log(`TeamVesting deployed to ${teamVestingResult.address}\n`); - - // const deployExecutorResult = await hre.deployments.deploy("Executor", { - // from: deployer, - // proxy: { - // proxyContract: "ERC1967Proxy", - // proxyArgs: ["{implementation}", "{data}"], - // execute: { - // methodName: "initialize", - // args: [180], - // }, - // }, - // waitConfirmations: 1, - // }); - - // console.log(`Executor deployed to ${deployExecutorResult.address}`); - - // const deployDAOResult = await hre.deployments.deploy("Governor", { - // from: deployer, - // proxy: { - // proxyContract: "ERC1967Proxy", - // proxyArgs: ["{implementation}", "{data}"], - // execute: { - // methodName: "initialize", - // args: [ - // token.address, - // teamVestingResult.address, - // deployExecutorResult.address, - // 1, // quorum - // Math.floor((10 * MINUTES) / 12), // voting delay - // Math.floor((10 * MINUTES) / 12), // voting period - // ethers.utils.parseEther("1000"), // proposal threshold - // ], - // }, - // }, - // waitConfirmations: 1, - // }); - - // console.log(`Governor deployed to ${deployDAOResult.address}`); }; export default func; diff --git a/contracts/deployments/sepolia/DevRewardDistributor.json b/contracts/deployments/sepolia/DevRewardDistributor.json index e04c776..f364b48 100644 --- a/contracts/deployments/sepolia/DevRewardDistributor.json +++ b/contracts/deployments/sepolia/DevRewardDistributor.json @@ -1,5 +1,5 @@ { - "address": "0x56dCb8dDD86B970a5229c4B0DB8f5B179A9a651D", + "address": "0xFC3D7144d302Bc19B2363Fb28F3061a14255996d", "abi": [ { "inputs": [ @@ -529,34 +529,34 @@ "type": "function" } ], - "transactionHash": "0x2401bfa64a5b37fff99618a14080a8d7d34f43a3febdae906d85ae4bbf4acb54", + "transactionHash": "0xe182edcd6c917908e909f04fc514b7199b776443a2304aba9581f174c7e80e00", "receipt": { "to": null, "from": "0x85fbC7b5087cC7b4Fe3Fe97755D8E01c9Fd727D9", - "contractAddress": "0x56dCb8dDD86B970a5229c4B0DB8f5B179A9a651D", - "transactionIndex": 123, + "contractAddress": "0xFC3D7144d302Bc19B2363Fb28F3061a14255996d", + "transactionIndex": 90, "gasUsed": "1389499", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "blockHash": "0x3b5f25323faec041a7ec1b43f28b9e9eb495e66abc2a550eadd291e71c296a78", - "transactionHash": "0x2401bfa64a5b37fff99618a14080a8d7d34f43a3febdae906d85ae4bbf4acb54", + "blockHash": "0xdef2d71ca718d53f527d8b3bbd7b97b97d0d74444d3d0735dd06d8ca08d4eb12", + "transactionHash": "0xe182edcd6c917908e909f04fc514b7199b776443a2304aba9581f174c7e80e00", "logs": [], - "blockNumber": 5370536, - "cumulativeGasUsed": "23071537", + "blockNumber": 5375371, + "cumulativeGasUsed": "6662545", "status": 1, "byzantium": true }, "args": [ "0x1e554D8f3Bd07D27ef47DD4571a16CDA74c3b731", "0x85fbC7b5087cC7b4Fe3Fe97755D8E01c9Fd727D9", - "0x82e1cd2ef5365e6db5b707763079758302a04bb39e2b5199f460fc316b74890a", - 7200, - 600, - "1000000000000000000000", - 72000, + "0x9054c3420799d2857b3706ca310823473c3b76dd666412134952aeba279e888a", + 1800, + 300, + "5000000000000000000000", + 31104000, "0x85fbC7b5087cC7b4Fe3Fe97755D8E01c9Fd727D9", - "1000000000000000000000000000" + "50000000000000000000000000" ], - "numDeployments": 4, + "numDeployments": 5, "solcInputHash": "1b5b9e9927bb594251d0c4a6478849e1", "metadata": "{\"compiler\":{\"version\":\"0.8.20+commit.a1b79de6\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"contract FluenceToken\",\"name\":\"_token\",\"type\":\"address\"},{\"internalType\":\"contract Executor\",\"name\":\"_executor\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"_merkleRoot\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"_halvePeriod\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_lockupPeriod\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_initialReward\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_claimingPeriod\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"_canceler\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_maxClaimedSupply\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"AddressEmptyCode\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"AddressInsufficientBalance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ECDSAInvalidSignature\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"length\",\"type\":\"uint256\"}],\"name\":\"ECDSAInvalidSignatureLength\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"ECDSAInvalidSignatureS\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedInnerCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"userId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"leaf\",\"type\":\"bytes32\"}],\"name\":\"Claimed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"TransferUnclaimed\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"canceler\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"userId\",\"type\":\"uint32\"},{\"internalType\":\"bytes32[]\",\"name\":\"merkleProof\",\"type\":\"bytes32[]\"},{\"internalType\":\"address\",\"name\":\"temporaryAddress\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"name\":\"claimTokens\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"claimedSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"claimingEndTime\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"currentReward\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"deployTime\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"executor\",\"outputs\":[{\"internalType\":\"contract Executor\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"halvePeriod\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"initialReward\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"}],\"name\":\"isClaimed\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isClaimingActive\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"lockedBalances\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"unlockTime\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lockupPeriod\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"maxClaimedSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"merkleRoot\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"token\",\"outputs\":[{\"internalType\":\"contract FluenceToken\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"errors\":{\"AddressEmptyCode(address)\":[{\"details\":\"There's no code at `target` (it is not a contract).\"}],\"AddressInsufficientBalance(address)\":[{\"details\":\"The ETH balance of the account is not enough to perform the operation.\"}],\"ECDSAInvalidSignature()\":[{\"details\":\"The signature derives the `address(0)`.\"}],\"ECDSAInvalidSignatureLength(uint256)\":[{\"details\":\"The signature has an invalid length.\"}],\"ECDSAInvalidSignatureS(bytes32)\":[{\"details\":\"The signature has an S value that is in the upper half order.\"}],\"FailedInnerCall()\":[{\"details\":\"A call to an address target failed. The target may have reverted.\"}],\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC20 token failed.\"}]},\"events\":{\"Claimed(uint256,address,uint256,bytes32)\":{\"params\":{\"account\":\"- reward account\",\"amount\":\"- reward amount\",\"leaf\":\"- leaf with user's info in reward tree\",\"userId\":\"- reward user id\"}},\"Transfer(address,address,uint256)\":{\"details\":\"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero.\"},\"TransferUnclaimed(uint256)\":{\"params\":{\"amount\":\"- remainder balance\"}}},\"kind\":\"dev\",\"methods\":{\"claimTokens(uint32,bytes32[],address,bytes)\":{\"params\":{\"merkleProof\":\"- merkle proof for leaf\",\"signature\":\"- signature of temporary Ethereum address\",\"temporaryAddress\":\"- temporary Ethereum address that's used only for signing\",\"userId\":\"- user id in merkle tree\"}},\"constructor\":{\"params\":{\"_canceler\":\"- can cancel distribution, and withdraw to _executor.\",\"_claimingPeriod\":\"- claiming period\",\"_executor\":\"- DAO timelock contract\",\"_halvePeriod\":\"- period for dividing the reward\",\"_initialReward\":\"- initial user reward\",\"_merkleRoot\":\"- merkle root from rewards tree\",\"_token\":\"- reward token\"}},\"currentReward()\":{\"returns\":{\"_0\":\"- boolean\"}},\"isClaimed(uint256)\":{\"details\":\"fork from uniswap merkle distributor, unmodified\",\"returns\":{\"_0\":\"- boolean\"}},\"isClaimingActive()\":{\"returns\":{\"_0\":\"- boolean\"}}},\"title\":\"DevRewardDistributor\",\"version\":1},\"userdoc\":{\"events\":{\"Claimed(uint256,address,uint256,bytes32)\":{\"notice\":\"Emitted when user claims reward\"},\"TransferUnclaimed(uint256)\":{\"notice\":\"Emitted when claiming period is ended and tokens transfer to the executor\"}},\"kind\":\"user\",\"methods\":{\"canceler()\":{\"notice\":\"Canceler address (e.g. FluenceMultisig)\"},\"claimTokens(uint32,bytes32[],address,bytes)\":{\"notice\":\"Claim reward token\"},\"claimingEndTime()\":{\"notice\":\"Claiming end time\"},\"currentReward()\":{\"notice\":\"Get current user's reward\"},\"decimals()\":{\"notice\":\"Returns the vesting contract decimals\"},\"deployTime()\":{\"notice\":\"Time when this contract was deployed\"},\"executor()\":{\"notice\":\"DAO timelock contract address\"},\"halvePeriod()\":{\"notice\":\"Period for dividing the reward\"},\"initialReward()\":{\"notice\":\"Initial user's reward\"},\"isClaimed(uint256)\":{\"notice\":\"checks claimed bitMap for userId\"},\"isClaimingActive()\":{\"notice\":\"Checking if claiming is active\"},\"merkleRoot()\":{\"notice\":\"Merkle root from rewards tree\"},\"token()\":{\"notice\":\"Reward token\"},\"withdraw()\":{\"notice\":\"used to move any remaining tokens out of the contract to Executor (DAO) in emergency situation.\"}},\"notice\":\"Contract for managing developers reward\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/DevRewardDistributor.sol\":\"DevRewardDistributor\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (access/AccessControl.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAccessControl} from \\\"@openzeppelin/contracts/access/IAccessControl.sol\\\";\\nimport {ContextUpgradeable} from \\\"../utils/ContextUpgradeable.sol\\\";\\nimport {ERC165Upgradeable} from \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport {Initializable} from \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module that allows children to implement role-based access\\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\\n * members except through off-chain means by accessing the contract event logs. Some\\n * applications may benefit from on-chain enumerability, for those cases see\\n * {AccessControlEnumerable}.\\n *\\n * Roles are referred to by their `bytes32` identifier. These should be exposed\\n * in the external API and be unique. The best way to achieve this is by\\n * using `public constant` hash digests:\\n *\\n * ```solidity\\n * bytes32 public constant MY_ROLE = keccak256(\\\"MY_ROLE\\\");\\n * ```\\n *\\n * Roles can be used to represent a set of permissions. To restrict access to a\\n * function call, use {hasRole}:\\n *\\n * ```solidity\\n * function foo() public {\\n * require(hasRole(MY_ROLE, msg.sender));\\n * ...\\n * }\\n * ```\\n *\\n * Roles can be granted and revoked dynamically via the {grantRole} and\\n * {revokeRole} functions. Each role has an associated admin role, and only\\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\\n *\\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\\n * that only accounts with this role will be able to grant or revoke other\\n * roles. More complex role relationships can be created by using\\n * {_setRoleAdmin}.\\n *\\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\\n * grant and revoke this role. Extra precautions should be taken to secure\\n * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}\\n * to enforce additional security measures for this role.\\n */\\nabstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControl, ERC165Upgradeable {\\n struct RoleData {\\n mapping(address account => bool) hasRole;\\n bytes32 adminRole;\\n }\\n\\n bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\\n\\n\\n /// @custom:storage-location erc7201:openzeppelin.storage.AccessControl\\n struct AccessControlStorage {\\n mapping(bytes32 role => RoleData) _roles;\\n }\\n\\n // keccak256(abi.encode(uint256(keccak256(\\\"openzeppelin.storage.AccessControl\\\")) - 1)) & ~bytes32(uint256(0xff))\\n bytes32 private constant AccessControlStorageLocation = 0x02dd7bc7dec4dceedda775e58dd541e08a116c6c53815c0bd028192f7b626800;\\n\\n function _getAccessControlStorage() private pure returns (AccessControlStorage storage $) {\\n assembly {\\n $.slot := AccessControlStorageLocation\\n }\\n }\\n\\n /**\\n * @dev Modifier that checks that an account has a specific role. Reverts\\n * with an {AccessControlUnauthorizedAccount} error including the required role.\\n */\\n modifier onlyRole(bytes32 role) {\\n _checkRole(role);\\n _;\\n }\\n\\n function __AccessControl_init() internal onlyInitializing {\\n }\\n\\n function __AccessControl_init_unchained() internal onlyInitializing {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) public view virtual returns (bool) {\\n AccessControlStorage storage $ = _getAccessControlStorage();\\n return $._roles[role].hasRole[account];\\n }\\n\\n /**\\n * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `_msgSender()`\\n * is missing `role`. Overriding this function changes the behavior of the {onlyRole} modifier.\\n */\\n function _checkRole(bytes32 role) internal view virtual {\\n _checkRole(role, _msgSender());\\n }\\n\\n /**\\n * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `account`\\n * is missing `role`.\\n */\\n function _checkRole(bytes32 role, address account) internal view virtual {\\n if (!hasRole(role, account)) {\\n revert AccessControlUnauthorizedAccount(account, role);\\n }\\n }\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) public view virtual returns (bytes32) {\\n AccessControlStorage storage $ = _getAccessControlStorage();\\n return $._roles[role].adminRole;\\n }\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n *\\n * May emit a {RoleGranted} event.\\n */\\n function grantRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {\\n _grantRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n *\\n * May emit a {RoleRevoked} event.\\n */\\n function revokeRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {\\n _revokeRole(role, account);\\n }\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been revoked `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `callerConfirmation`.\\n *\\n * May emit a {RoleRevoked} event.\\n */\\n function renounceRole(bytes32 role, address callerConfirmation) public virtual {\\n if (callerConfirmation != _msgSender()) {\\n revert AccessControlBadConfirmation();\\n }\\n\\n _revokeRole(role, callerConfirmation);\\n }\\n\\n /**\\n * @dev Sets `adminRole` as ``role``'s admin role.\\n *\\n * Emits a {RoleAdminChanged} event.\\n */\\n function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\\n AccessControlStorage storage $ = _getAccessControlStorage();\\n bytes32 previousAdminRole = getRoleAdmin(role);\\n $._roles[role].adminRole = adminRole;\\n emit RoleAdminChanged(role, previousAdminRole, adminRole);\\n }\\n\\n /**\\n * @dev Attempts to grant `role` to `account` and returns a boolean indicating if `role` was granted.\\n *\\n * Internal function without access restriction.\\n *\\n * May emit a {RoleGranted} event.\\n */\\n function _grantRole(bytes32 role, address account) internal virtual returns (bool) {\\n AccessControlStorage storage $ = _getAccessControlStorage();\\n if (!hasRole(role, account)) {\\n $._roles[role].hasRole[account] = true;\\n emit RoleGranted(role, account, _msgSender());\\n return true;\\n } else {\\n return false;\\n }\\n }\\n\\n /**\\n * @dev Attempts to revoke `role` to `account` and returns a boolean indicating if `role` was revoked.\\n *\\n * Internal function without access restriction.\\n *\\n * May emit a {RoleRevoked} event.\\n */\\n function _revokeRole(bytes32 role, address account) internal virtual returns (bool) {\\n AccessControlStorage storage $ = _getAccessControlStorage();\\n if (hasRole(role, account)) {\\n $._roles[role].hasRole[account] = false;\\n emit RoleRevoked(role, account, _msgSender());\\n return true;\\n } else {\\n return false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x6662ec4e5cefca03eeadd073e9469df8d2944bb2ee8ec8f7622c2c46aab5f225\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {ContextUpgradeable} from \\\"../utils/ContextUpgradeable.sol\\\";\\nimport {Initializable} from \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * The initial owner is set to the address provided by the deployer. This can\\n * later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\\n /// @custom:storage-location erc7201:openzeppelin.storage.Ownable\\n struct OwnableStorage {\\n address _owner;\\n }\\n\\n // keccak256(abi.encode(uint256(keccak256(\\\"openzeppelin.storage.Ownable\\\")) - 1)) & ~bytes32(uint256(0xff))\\n bytes32 private constant OwnableStorageLocation = 0x9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c199300;\\n\\n function _getOwnableStorage() private pure returns (OwnableStorage storage $) {\\n assembly {\\n $.slot := OwnableStorageLocation\\n }\\n }\\n\\n /**\\n * @dev The caller account is not authorized to perform an operation.\\n */\\n error OwnableUnauthorizedAccount(address account);\\n\\n /**\\n * @dev The owner is not a valid owner account. (eg. `address(0)`)\\n */\\n error OwnableInvalidOwner(address owner);\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the address provided by the deployer as the initial owner.\\n */\\n function __Ownable_init(address initialOwner) internal onlyInitializing {\\n __Ownable_init_unchained(initialOwner);\\n }\\n\\n function __Ownable_init_unchained(address initialOwner) internal onlyInitializing {\\n if (initialOwner == address(0)) {\\n revert OwnableInvalidOwner(address(0));\\n }\\n _transferOwnership(initialOwner);\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n OwnableStorage storage $ = _getOwnableStorage();\\n return $._owner;\\n }\\n\\n /**\\n * @dev Throws if the sender is not the owner.\\n */\\n function _checkOwner() internal view virtual {\\n if (owner() != _msgSender()) {\\n revert OwnableUnauthorizedAccount(_msgSender());\\n }\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby disabling any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n _transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n if (newOwner == address(0)) {\\n revert OwnableInvalidOwner(address(0));\\n }\\n _transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n OwnableStorage storage $ = _getOwnableStorage();\\n address oldOwner = $._owner;\\n $._owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n}\\n\",\"keccak256\":\"0xc163fcf9bb10138631a9ba5564df1fa25db9adff73bd9ee868a8ae1858fe093a\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/governance/GovernorUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (governance/Governor.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC721Receiver} from \\\"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol\\\";\\nimport {IERC1155Receiver} from \\\"@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol\\\";\\nimport {EIP712Upgradeable} from \\\"../utils/cryptography/EIP712Upgradeable.sol\\\";\\nimport {SignatureChecker} from \\\"@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol\\\";\\nimport {IERC165} from \\\"@openzeppelin/contracts/utils/introspection/IERC165.sol\\\";\\nimport {ERC165Upgradeable} from \\\"../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport {SafeCast} from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport {DoubleEndedQueue} from \\\"@openzeppelin/contracts/utils/structs/DoubleEndedQueue.sol\\\";\\nimport {Address} from \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport {ContextUpgradeable} from \\\"../utils/ContextUpgradeable.sol\\\";\\nimport {NoncesUpgradeable} from \\\"../utils/NoncesUpgradeable.sol\\\";\\nimport {IGovernor} from \\\"@openzeppelin/contracts/governance/IGovernor.sol\\\";\\nimport {IERC6372} from \\\"@openzeppelin/contracts/interfaces/IERC6372.sol\\\";\\nimport {Initializable} from \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Core of the governance system, designed to be extended through various modules.\\n *\\n * This contract is abstract and requires several functions to be implemented in various modules:\\n *\\n * - A counting module must implement {quorum}, {_quorumReached}, {_voteSucceeded} and {_countVote}\\n * - A voting module must implement {_getVotes}\\n * - Additionally, {votingPeriod} must also be implemented\\n */\\nabstract contract GovernorUpgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, EIP712Upgradeable, NoncesUpgradeable, IGovernor, IERC721Receiver, IERC1155Receiver {\\n using DoubleEndedQueue for DoubleEndedQueue.Bytes32Deque;\\n\\n bytes32 public constant BALLOT_TYPEHASH =\\n keccak256(\\\"Ballot(uint256 proposalId,uint8 support,address voter,uint256 nonce)\\\");\\n bytes32 public constant EXTENDED_BALLOT_TYPEHASH =\\n keccak256(\\n \\\"ExtendedBallot(uint256 proposalId,uint8 support,address voter,uint256 nonce,string reason,bytes params)\\\"\\n );\\n\\n struct ProposalCore {\\n address proposer;\\n uint48 voteStart;\\n uint32 voteDuration;\\n bool executed;\\n bool canceled;\\n uint48 etaSeconds;\\n }\\n\\n bytes32 private constant ALL_PROPOSAL_STATES_BITMAP = bytes32((2 ** (uint8(type(ProposalState).max) + 1)) - 1);\\n /// @custom:storage-location erc7201:openzeppelin.storage.Governor\\n struct GovernorStorage {\\n string _name;\\n\\n mapping(uint256 proposalId => ProposalCore) _proposals;\\n\\n // This queue keeps track of the governor operating on itself. Calls to functions protected by the {onlyGovernance}\\n // modifier needs to be whitelisted in this queue. Whitelisting is set in {execute}, consumed by the\\n // {onlyGovernance} modifier and eventually reset after {_executeOperations} completes. This ensures that the\\n // execution of {onlyGovernance} protected calls can only be achieved through successful proposals.\\n DoubleEndedQueue.Bytes32Deque _governanceCall;\\n }\\n\\n // keccak256(abi.encode(uint256(keccak256(\\\"openzeppelin.storage.Governor\\\")) - 1)) & ~bytes32(uint256(0xff))\\n bytes32 private constant GovernorStorageLocation = 0x7c712897014dbe49c045ef1299aa2d5f9e67e48eea4403efa21f1e0f3ac0cb00;\\n\\n function _getGovernorStorage() private pure returns (GovernorStorage storage $) {\\n assembly {\\n $.slot := GovernorStorageLocation\\n }\\n }\\n\\n /**\\n * @dev Restricts a function so it can only be executed through governance proposals. For example, governance\\n * parameter setters in {GovernorSettings} are protected using this modifier.\\n *\\n * The governance executing address may be different from the Governor's own address, for example it could be a\\n * timelock. This can be customized by modules by overriding {_executor}. The executor is only able to invoke these\\n * functions during the execution of the governor's {execute} function, and not under any other circumstances. Thus,\\n * for example, additional timelock proposers are not able to change governance parameters without going through the\\n * governance protocol (since v4.6).\\n */\\n modifier onlyGovernance() {\\n _checkGovernance();\\n _;\\n }\\n\\n /**\\n * @dev Sets the value for {name} and {version}\\n */\\n function __Governor_init(string memory name_) internal onlyInitializing {\\n __EIP712_init_unchained(name_, version());\\n __Governor_init_unchained(name_);\\n }\\n\\n function __Governor_init_unchained(string memory name_) internal onlyInitializing {\\n GovernorStorage storage $ = _getGovernorStorage();\\n $._name = name_;\\n }\\n\\n /**\\n * @dev Function to receive ETH that will be handled by the governor (disabled if executor is a third party contract)\\n */\\n receive() external payable virtual {\\n if (_executor() != address(this)) {\\n revert GovernorDisabledDeposit();\\n }\\n }\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165Upgradeable) returns (bool) {\\n return\\n interfaceId == type(IGovernor).interfaceId ||\\n interfaceId == type(IERC1155Receiver).interfaceId ||\\n super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev See {IGovernor-name}.\\n */\\n function name() public view virtual returns (string memory) {\\n GovernorStorage storage $ = _getGovernorStorage();\\n return $._name;\\n }\\n\\n /**\\n * @dev See {IGovernor-version}.\\n */\\n function version() public view virtual returns (string memory) {\\n return \\\"1\\\";\\n }\\n\\n /**\\n * @dev See {IGovernor-hashProposal}.\\n *\\n * The proposal id is produced by hashing the ABI encoded `targets` array, the `values` array, the `calldatas` array\\n * and the descriptionHash (bytes32 which itself is the keccak256 hash of the description string). This proposal id\\n * can be produced from the proposal data which is part of the {ProposalCreated} event. It can even be computed in\\n * advance, before the proposal is submitted.\\n *\\n * Note that the chainId and the governor address are not part of the proposal id computation. Consequently, the\\n * same proposal (with same operation and same description) will have the same id if submitted on multiple governors\\n * across multiple networks. This also means that in order to execute the same operation twice (on the same\\n * governor) the proposer will have to change the description in order to avoid proposal id conflicts.\\n */\\n function hashProposal(\\n address[] memory targets,\\n uint256[] memory values,\\n bytes[] memory calldatas,\\n bytes32 descriptionHash\\n ) public pure virtual returns (uint256) {\\n return uint256(keccak256(abi.encode(targets, values, calldatas, descriptionHash)));\\n }\\n\\n /**\\n * @dev See {IGovernor-state}.\\n */\\n function state(uint256 proposalId) public view virtual returns (ProposalState) {\\n GovernorStorage storage $ = _getGovernorStorage();\\n // We read the struct fields into the stack at once so Solidity emits a single SLOAD\\n ProposalCore storage proposal = $._proposals[proposalId];\\n bool proposalExecuted = proposal.executed;\\n bool proposalCanceled = proposal.canceled;\\n\\n if (proposalExecuted) {\\n return ProposalState.Executed;\\n }\\n\\n if (proposalCanceled) {\\n return ProposalState.Canceled;\\n }\\n\\n uint256 snapshot = proposalSnapshot(proposalId);\\n\\n if (snapshot == 0) {\\n revert GovernorNonexistentProposal(proposalId);\\n }\\n\\n uint256 currentTimepoint = clock();\\n\\n if (snapshot >= currentTimepoint) {\\n return ProposalState.Pending;\\n }\\n\\n uint256 deadline = proposalDeadline(proposalId);\\n\\n if (deadline >= currentTimepoint) {\\n return ProposalState.Active;\\n } else if (!_quorumReached(proposalId) || !_voteSucceeded(proposalId)) {\\n return ProposalState.Defeated;\\n } else if (proposalEta(proposalId) == 0) {\\n return ProposalState.Succeeded;\\n } else {\\n return ProposalState.Queued;\\n }\\n }\\n\\n /**\\n * @dev See {IGovernor-proposalThreshold}.\\n */\\n function proposalThreshold() public view virtual returns (uint256) {\\n return 0;\\n }\\n\\n /**\\n * @dev See {IGovernor-proposalSnapshot}.\\n */\\n function proposalSnapshot(uint256 proposalId) public view virtual returns (uint256) {\\n GovernorStorage storage $ = _getGovernorStorage();\\n return $._proposals[proposalId].voteStart;\\n }\\n\\n /**\\n * @dev See {IGovernor-proposalDeadline}.\\n */\\n function proposalDeadline(uint256 proposalId) public view virtual returns (uint256) {\\n GovernorStorage storage $ = _getGovernorStorage();\\n return $._proposals[proposalId].voteStart + $._proposals[proposalId].voteDuration;\\n }\\n\\n /**\\n * @dev See {IGovernor-proposalProposer}.\\n */\\n function proposalProposer(uint256 proposalId) public view virtual returns (address) {\\n GovernorStorage storage $ = _getGovernorStorage();\\n return $._proposals[proposalId].proposer;\\n }\\n\\n /**\\n * @dev See {IGovernor-proposalEta}.\\n */\\n function proposalEta(uint256 proposalId) public view virtual returns (uint256) {\\n GovernorStorage storage $ = _getGovernorStorage();\\n return $._proposals[proposalId].etaSeconds;\\n }\\n\\n /**\\n * @dev See {IGovernor-proposalNeedsQueuing}.\\n */\\n function proposalNeedsQueuing(uint256) public view virtual returns (bool) {\\n return false;\\n }\\n\\n /**\\n * @dev Reverts if the `msg.sender` is not the executor. In case the executor is not this contract\\n * itself, the function reverts if `msg.data` is not whitelisted as a result of an {execute}\\n * operation. See {onlyGovernance}.\\n */\\n function _checkGovernance() internal virtual {\\n GovernorStorage storage $ = _getGovernorStorage();\\n if (_executor() != _msgSender()) {\\n revert GovernorOnlyExecutor(_msgSender());\\n }\\n if (_executor() != address(this)) {\\n bytes32 msgDataHash = keccak256(_msgData());\\n // loop until popping the expected operation - throw if deque is empty (operation not authorized)\\n while ($._governanceCall.popFront() != msgDataHash) {}\\n }\\n }\\n\\n /**\\n * @dev Amount of votes already cast passes the threshold limit.\\n */\\n function _quorumReached(uint256 proposalId) internal view virtual returns (bool);\\n\\n /**\\n * @dev Is the proposal successful or not.\\n */\\n function _voteSucceeded(uint256 proposalId) internal view virtual returns (bool);\\n\\n /**\\n * @dev Get the voting weight of `account` at a specific `timepoint`, for a vote as described by `params`.\\n */\\n function _getVotes(address account, uint256 timepoint, bytes memory params) internal view virtual returns (uint256);\\n\\n /**\\n * @dev Register a vote for `proposalId` by `account` with a given `support`, voting `weight` and voting `params`.\\n *\\n * Note: Support is generic and can represent various things depending on the voting system used.\\n */\\n function _countVote(\\n uint256 proposalId,\\n address account,\\n uint8 support,\\n uint256 weight,\\n bytes memory params\\n ) internal virtual;\\n\\n /**\\n * @dev Default additional encoded parameters used by castVote methods that don't include them\\n *\\n * Note: Should be overridden by specific implementations to use an appropriate value, the\\n * meaning of the additional params, in the context of that implementation\\n */\\n function _defaultParams() internal view virtual returns (bytes memory) {\\n return \\\"\\\";\\n }\\n\\n /**\\n * @dev See {IGovernor-propose}. This function has opt-in frontrunning protection, described in {_isValidDescriptionForProposer}.\\n */\\n function propose(\\n address[] memory targets,\\n uint256[] memory values,\\n bytes[] memory calldatas,\\n string memory description\\n ) public virtual returns (uint256) {\\n address proposer = _msgSender();\\n\\n // check description restriction\\n if (!_isValidDescriptionForProposer(proposer, description)) {\\n revert GovernorRestrictedProposer(proposer);\\n }\\n\\n // check proposal threshold\\n uint256 proposerVotes = getVotes(proposer, clock() - 1);\\n uint256 votesThreshold = proposalThreshold();\\n if (proposerVotes < votesThreshold) {\\n revert GovernorInsufficientProposerVotes(proposer, proposerVotes, votesThreshold);\\n }\\n\\n return _propose(targets, values, calldatas, description, proposer);\\n }\\n\\n /**\\n * @dev Internal propose mechanism. Can be overridden to add more logic on proposal creation.\\n *\\n * Emits a {IGovernor-ProposalCreated} event.\\n */\\n function _propose(\\n address[] memory targets,\\n uint256[] memory values,\\n bytes[] memory calldatas,\\n string memory description,\\n address proposer\\n ) internal virtual returns (uint256 proposalId) {\\n GovernorStorage storage $ = _getGovernorStorage();\\n proposalId = hashProposal(targets, values, calldatas, keccak256(bytes(description)));\\n\\n if (targets.length != values.length || targets.length != calldatas.length || targets.length == 0) {\\n revert GovernorInvalidProposalLength(targets.length, calldatas.length, values.length);\\n }\\n if ($._proposals[proposalId].voteStart != 0) {\\n revert GovernorUnexpectedProposalState(proposalId, state(proposalId), bytes32(0));\\n }\\n\\n uint256 snapshot = clock() + votingDelay();\\n uint256 duration = votingPeriod();\\n\\n ProposalCore storage proposal = $._proposals[proposalId];\\n proposal.proposer = proposer;\\n proposal.voteStart = SafeCast.toUint48(snapshot);\\n proposal.voteDuration = SafeCast.toUint32(duration);\\n\\n emit ProposalCreated(\\n proposalId,\\n proposer,\\n targets,\\n values,\\n new string[](targets.length),\\n calldatas,\\n snapshot,\\n snapshot + duration,\\n description\\n );\\n\\n // Using a named return variable to avoid stack too deep errors\\n }\\n\\n /**\\n * @dev See {IGovernor-queue}.\\n */\\n function queue(\\n address[] memory targets,\\n uint256[] memory values,\\n bytes[] memory calldatas,\\n bytes32 descriptionHash\\n ) public virtual returns (uint256) {\\n GovernorStorage storage $ = _getGovernorStorage();\\n uint256 proposalId = hashProposal(targets, values, calldatas, descriptionHash);\\n\\n _validateStateBitmap(proposalId, _encodeStateBitmap(ProposalState.Succeeded));\\n\\n uint48 etaSeconds = _queueOperations(proposalId, targets, values, calldatas, descriptionHash);\\n\\n if (etaSeconds != 0) {\\n $._proposals[proposalId].etaSeconds = etaSeconds;\\n emit ProposalQueued(proposalId, etaSeconds);\\n } else {\\n revert GovernorQueueNotImplemented();\\n }\\n\\n return proposalId;\\n }\\n\\n /**\\n * @dev Internal queuing mechanism. Can be overridden (without a super call) to modify the way queuing is\\n * performed (for example adding a vault/timelock).\\n *\\n * This is empty by default, and must be overridden to implement queuing.\\n *\\n * This function returns a timestamp that describes the expected ETA for execution. If the returned value is 0\\n * (which is the default value), the core will consider queueing did not succeed, and the public {queue} function\\n * will revert.\\n *\\n * NOTE: Calling this function directly will NOT check the current state of the proposal, or emit the\\n * `ProposalQueued` event. Queuing a proposal should be done using {queue}.\\n */\\n function _queueOperations(\\n uint256 /*proposalId*/,\\n address[] memory /*targets*/,\\n uint256[] memory /*values*/,\\n bytes[] memory /*calldatas*/,\\n bytes32 /*descriptionHash*/\\n ) internal virtual returns (uint48) {\\n return 0;\\n }\\n\\n /**\\n * @dev See {IGovernor-execute}.\\n */\\n function execute(\\n address[] memory targets,\\n uint256[] memory values,\\n bytes[] memory calldatas,\\n bytes32 descriptionHash\\n ) public payable virtual returns (uint256) {\\n GovernorStorage storage $ = _getGovernorStorage();\\n uint256 proposalId = hashProposal(targets, values, calldatas, descriptionHash);\\n\\n _validateStateBitmap(\\n proposalId,\\n _encodeStateBitmap(ProposalState.Succeeded) | _encodeStateBitmap(ProposalState.Queued)\\n );\\n\\n // mark as executed before calls to avoid reentrancy\\n $._proposals[proposalId].executed = true;\\n\\n // before execute: register governance call in queue.\\n if (_executor() != address(this)) {\\n for (uint256 i = 0; i < targets.length; ++i) {\\n if (targets[i] == address(this)) {\\n $._governanceCall.pushBack(keccak256(calldatas[i]));\\n }\\n }\\n }\\n\\n _executeOperations(proposalId, targets, values, calldatas, descriptionHash);\\n\\n // after execute: cleanup governance call queue.\\n if (_executor() != address(this) && !$._governanceCall.empty()) {\\n $._governanceCall.clear();\\n }\\n\\n emit ProposalExecuted(proposalId);\\n\\n return proposalId;\\n }\\n\\n /**\\n * @dev Internal execution mechanism. Can be overridden (without a super call) to modify the way execution is\\n * performed (for example adding a vault/timelock).\\n *\\n * NOTE: Calling this function directly will NOT check the current state of the proposal, set the executed flag to\\n * true or emit the `ProposalExecuted` event. Executing a proposal should be done using {execute} or {_execute}.\\n */\\n function _executeOperations(\\n uint256 /* proposalId */,\\n address[] memory targets,\\n uint256[] memory values,\\n bytes[] memory calldatas,\\n bytes32 /*descriptionHash*/\\n ) internal virtual {\\n for (uint256 i = 0; i < targets.length; ++i) {\\n (bool success, bytes memory returndata) = targets[i].call{value: values[i]}(calldatas[i]);\\n Address.verifyCallResult(success, returndata);\\n }\\n }\\n\\n /**\\n * @dev See {IGovernor-cancel}.\\n */\\n function cancel(\\n address[] memory targets,\\n uint256[] memory values,\\n bytes[] memory calldatas,\\n bytes32 descriptionHash\\n ) public virtual returns (uint256) {\\n // The proposalId will be recomputed in the `_cancel` call further down. However we need the value before we\\n // do the internal call, because we need to check the proposal state BEFORE the internal `_cancel` call\\n // changes it. The `hashProposal` duplication has a cost that is limited, and that we accept.\\n uint256 proposalId = hashProposal(targets, values, calldatas, descriptionHash);\\n\\n // public cancel restrictions (on top of existing _cancel restrictions).\\n _validateStateBitmap(proposalId, _encodeStateBitmap(ProposalState.Pending));\\n if (_msgSender() != proposalProposer(proposalId)) {\\n revert GovernorOnlyProposer(_msgSender());\\n }\\n\\n return _cancel(targets, values, calldatas, descriptionHash);\\n }\\n\\n /**\\n * @dev Internal cancel mechanism with minimal restrictions. A proposal can be cancelled in any state other than\\n * Canceled, Expired, or Executed. Once cancelled a proposal can't be re-submitted.\\n *\\n * Emits a {IGovernor-ProposalCanceled} event.\\n */\\n function _cancel(\\n address[] memory targets,\\n uint256[] memory values,\\n bytes[] memory calldatas,\\n bytes32 descriptionHash\\n ) internal virtual returns (uint256) {\\n GovernorStorage storage $ = _getGovernorStorage();\\n uint256 proposalId = hashProposal(targets, values, calldatas, descriptionHash);\\n\\n _validateStateBitmap(\\n proposalId,\\n ALL_PROPOSAL_STATES_BITMAP ^\\n _encodeStateBitmap(ProposalState.Canceled) ^\\n _encodeStateBitmap(ProposalState.Expired) ^\\n _encodeStateBitmap(ProposalState.Executed)\\n );\\n\\n $._proposals[proposalId].canceled = true;\\n emit ProposalCanceled(proposalId);\\n\\n return proposalId;\\n }\\n\\n /**\\n * @dev See {IGovernor-getVotes}.\\n */\\n function getVotes(address account, uint256 timepoint) public view virtual returns (uint256) {\\n return _getVotes(account, timepoint, _defaultParams());\\n }\\n\\n /**\\n * @dev See {IGovernor-getVotesWithParams}.\\n */\\n function getVotesWithParams(\\n address account,\\n uint256 timepoint,\\n bytes memory params\\n ) public view virtual returns (uint256) {\\n return _getVotes(account, timepoint, params);\\n }\\n\\n /**\\n * @dev See {IGovernor-castVote}.\\n */\\n function castVote(uint256 proposalId, uint8 support) public virtual returns (uint256) {\\n address voter = _msgSender();\\n return _castVote(proposalId, voter, support, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IGovernor-castVoteWithReason}.\\n */\\n function castVoteWithReason(\\n uint256 proposalId,\\n uint8 support,\\n string calldata reason\\n ) public virtual returns (uint256) {\\n address voter = _msgSender();\\n return _castVote(proposalId, voter, support, reason);\\n }\\n\\n /**\\n * @dev See {IGovernor-castVoteWithReasonAndParams}.\\n */\\n function castVoteWithReasonAndParams(\\n uint256 proposalId,\\n uint8 support,\\n string calldata reason,\\n bytes memory params\\n ) public virtual returns (uint256) {\\n address voter = _msgSender();\\n return _castVote(proposalId, voter, support, reason, params);\\n }\\n\\n /**\\n * @dev See {IGovernor-castVoteBySig}.\\n */\\n function castVoteBySig(\\n uint256 proposalId,\\n uint8 support,\\n address voter,\\n bytes memory signature\\n ) public virtual returns (uint256) {\\n bool valid = SignatureChecker.isValidSignatureNow(\\n voter,\\n _hashTypedDataV4(keccak256(abi.encode(BALLOT_TYPEHASH, proposalId, support, voter, _useNonce(voter)))),\\n signature\\n );\\n\\n if (!valid) {\\n revert GovernorInvalidSignature(voter);\\n }\\n\\n return _castVote(proposalId, voter, support, \\\"\\\");\\n }\\n\\n /**\\n * @dev See {IGovernor-castVoteWithReasonAndParamsBySig}.\\n */\\n function castVoteWithReasonAndParamsBySig(\\n uint256 proposalId,\\n uint8 support,\\n address voter,\\n string calldata reason,\\n bytes memory params,\\n bytes memory signature\\n ) public virtual returns (uint256) {\\n bool valid = SignatureChecker.isValidSignatureNow(\\n voter,\\n _hashTypedDataV4(\\n keccak256(\\n abi.encode(\\n EXTENDED_BALLOT_TYPEHASH,\\n proposalId,\\n support,\\n voter,\\n _useNonce(voter),\\n keccak256(bytes(reason)),\\n keccak256(params)\\n )\\n )\\n ),\\n signature\\n );\\n\\n if (!valid) {\\n revert GovernorInvalidSignature(voter);\\n }\\n\\n return _castVote(proposalId, voter, support, reason, params);\\n }\\n\\n /**\\n * @dev Internal vote casting mechanism: Check that the vote is pending, that it has not been cast yet, retrieve\\n * voting weight using {IGovernor-getVotes} and call the {_countVote} internal function. Uses the _defaultParams().\\n *\\n * Emits a {IGovernor-VoteCast} event.\\n */\\n function _castVote(\\n uint256 proposalId,\\n address account,\\n uint8 support,\\n string memory reason\\n ) internal virtual returns (uint256) {\\n return _castVote(proposalId, account, support, reason, _defaultParams());\\n }\\n\\n /**\\n * @dev Internal vote casting mechanism: Check that the vote is pending, that it has not been cast yet, retrieve\\n * voting weight using {IGovernor-getVotes} and call the {_countVote} internal function.\\n *\\n * Emits a {IGovernor-VoteCast} event.\\n */\\n function _castVote(\\n uint256 proposalId,\\n address account,\\n uint8 support,\\n string memory reason,\\n bytes memory params\\n ) internal virtual returns (uint256) {\\n _validateStateBitmap(proposalId, _encodeStateBitmap(ProposalState.Active));\\n\\n uint256 weight = _getVotes(account, proposalSnapshot(proposalId), params);\\n _countVote(proposalId, account, support, weight, params);\\n\\n if (params.length == 0) {\\n emit VoteCast(account, proposalId, support, weight, reason);\\n } else {\\n emit VoteCastWithParams(account, proposalId, support, weight, reason, params);\\n }\\n\\n return weight;\\n }\\n\\n /**\\n * @dev Relays a transaction or function call to an arbitrary target. In cases where the governance executor\\n * is some contract other than the governor itself, like when using a timelock, this function can be invoked\\n * in a governance proposal to recover tokens or Ether that was sent to the governor contract by mistake.\\n * Note that if the executor is simply the governor itself, use of `relay` is redundant.\\n */\\n function relay(address target, uint256 value, bytes calldata data) external payable virtual onlyGovernance {\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n Address.verifyCallResult(success, returndata);\\n }\\n\\n /**\\n * @dev Address through which the governor executes action. Will be overloaded by module that execute actions\\n * through another contract such as a timelock.\\n */\\n function _executor() internal view virtual returns (address) {\\n return address(this);\\n }\\n\\n /**\\n * @dev See {IERC721Receiver-onERC721Received}.\\n * Receiving tokens is disabled if the governance executor is other than the governor itself (eg. when using with a timelock).\\n */\\n function onERC721Received(address, address, uint256, bytes memory) public virtual returns (bytes4) {\\n if (_executor() != address(this)) {\\n revert GovernorDisabledDeposit();\\n }\\n return this.onERC721Received.selector;\\n }\\n\\n /**\\n * @dev See {IERC1155Receiver-onERC1155Received}.\\n * Receiving tokens is disabled if the governance executor is other than the governor itself (eg. when using with a timelock).\\n */\\n function onERC1155Received(address, address, uint256, uint256, bytes memory) public virtual returns (bytes4) {\\n if (_executor() != address(this)) {\\n revert GovernorDisabledDeposit();\\n }\\n return this.onERC1155Received.selector;\\n }\\n\\n /**\\n * @dev See {IERC1155Receiver-onERC1155BatchReceived}.\\n * Receiving tokens is disabled if the governance executor is other than the governor itself (eg. when using with a timelock).\\n */\\n function onERC1155BatchReceived(\\n address,\\n address,\\n uint256[] memory,\\n uint256[] memory,\\n bytes memory\\n ) public virtual returns (bytes4) {\\n if (_executor() != address(this)) {\\n revert GovernorDisabledDeposit();\\n }\\n return this.onERC1155BatchReceived.selector;\\n }\\n\\n /**\\n * @dev Encodes a `ProposalState` into a `bytes32` representation where each bit enabled corresponds to\\n * the underlying position in the `ProposalState` enum. For example:\\n *\\n * 0x000...10000\\n * ^^^^^^------ ...\\n * ^----- Succeeded\\n * ^---- Defeated\\n * ^--- Canceled\\n * ^-- Active\\n * ^- Pending\\n */\\n function _encodeStateBitmap(ProposalState proposalState) internal pure returns (bytes32) {\\n return bytes32(1 << uint8(proposalState));\\n }\\n\\n /**\\n * @dev Check that the current state of a proposal matches the requirements described by the `allowedStates` bitmap.\\n * This bitmap should be built using `_encodeStateBitmap`.\\n *\\n * If requirements are not met, reverts with a {GovernorUnexpectedProposalState} error.\\n */\\n function _validateStateBitmap(uint256 proposalId, bytes32 allowedStates) private view returns (ProposalState) {\\n ProposalState currentState = state(proposalId);\\n if (_encodeStateBitmap(currentState) & allowedStates == bytes32(0)) {\\n revert GovernorUnexpectedProposalState(proposalId, currentState, allowedStates);\\n }\\n return currentState;\\n }\\n\\n /*\\n * @dev Check if the proposer is authorized to submit a proposal with the given description.\\n *\\n * If the proposal description ends with `#proposer=0x???`, where `0x???` is an address written as a hex string\\n * (case insensitive), then the submission of this proposal will only be authorized to said address.\\n *\\n * This is used for frontrunning protection. By adding this pattern at the end of their proposal, one can ensure\\n * that no other address can submit the same proposal. An attacker would have to either remove or change that part,\\n * which would result in a different proposal id.\\n *\\n * If the description does not match this pattern, it is unrestricted and anyone can submit it. This includes:\\n * - If the `0x???` part is not a valid hex string.\\n * - If the `0x???` part is a valid hex string, but does not contain exactly 40 hex digits.\\n * - If it ends with the expected suffix followed by newlines or other whitespace.\\n * - If it ends with some other similar suffix, e.g. `#other=abc`.\\n * - If it does not end with any such suffix.\\n */\\n function _isValidDescriptionForProposer(\\n address proposer,\\n string memory description\\n ) internal view virtual returns (bool) {\\n uint256 len = bytes(description).length;\\n\\n // Length is too short to contain a valid proposer suffix\\n if (len < 52) {\\n return true;\\n }\\n\\n // Extract what would be the `#proposer=0x` marker beginning the suffix\\n bytes12 marker;\\n assembly {\\n // - Start of the string contents in memory = description + 32\\n // - First character of the marker = len - 52\\n // - Length of \\\"#proposer=0x0000000000000000000000000000000000000000\\\" = 52\\n // - We read the memory word starting at the first character of the marker:\\n // - (description + 32) + (len - 52) = description + (len - 20)\\n // - Note: Solidity will ignore anything past the first 12 bytes\\n marker := mload(add(description, sub(len, 20)))\\n }\\n\\n // If the marker is not found, there is no proposer suffix to check\\n if (marker != bytes12(\\\"#proposer=0x\\\")) {\\n return true;\\n }\\n\\n // Parse the 40 characters following the marker as uint160\\n uint160 recovered = 0;\\n for (uint256 i = len - 40; i < len; ++i) {\\n (bool isHex, uint8 value) = _tryHexToUint(bytes(description)[i]);\\n // If any of the characters is not a hex digit, ignore the suffix entirely\\n if (!isHex) {\\n return true;\\n }\\n recovered = (recovered << 4) | value;\\n }\\n\\n return recovered == uint160(proposer);\\n }\\n\\n /**\\n * @dev Try to parse a character from a string as a hex value. Returns `(true, value)` if the char is in\\n * `[0-9a-fA-F]` and `(false, 0)` otherwise. Value is guaranteed to be in the range `0 <= value < 16`\\n */\\n function _tryHexToUint(bytes1 char) private pure returns (bool, uint8) {\\n uint8 c = uint8(char);\\n unchecked {\\n // Case 0-9\\n if (47 < c && c < 58) {\\n return (true, c - 48);\\n }\\n // Case A-F\\n else if (64 < c && c < 71) {\\n return (true, c - 55);\\n }\\n // Case a-f\\n else if (96 < c && c < 103) {\\n return (true, c - 87);\\n }\\n // Else: not a hex char\\n else {\\n return (false, 0);\\n }\\n }\\n }\\n\\n /**\\n * @inheritdoc IERC6372\\n */\\n function clock() public view virtual returns (uint48);\\n\\n /**\\n * @inheritdoc IERC6372\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function CLOCK_MODE() public view virtual returns (string memory);\\n\\n /**\\n * @inheritdoc IGovernor\\n */\\n function votingDelay() public view virtual returns (uint256);\\n\\n /**\\n * @inheritdoc IGovernor\\n */\\n function votingPeriod() public view virtual returns (uint256);\\n\\n /**\\n * @inheritdoc IGovernor\\n */\\n function quorum(uint256 timepoint) public view virtual returns (uint256);\\n}\\n\",\"keccak256\":\"0x48c0abe4e150b1f36d2731931724f71c1908409ff4b2efcee3bef3b128eef735\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/governance/TimelockControllerUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (governance/TimelockController.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {AccessControlUpgradeable} from \\\"../access/AccessControlUpgradeable.sol\\\";\\nimport {ERC721HolderUpgradeable} from \\\"../token/ERC721/utils/ERC721HolderUpgradeable.sol\\\";\\nimport {ERC1155HolderUpgradeable} from \\\"../token/ERC1155/utils/ERC1155HolderUpgradeable.sol\\\";\\nimport {Address} from \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport {Initializable} from \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which acts as a timelocked controller. When set as the\\n * owner of an `Ownable` smart contract, it enforces a timelock on all\\n * `onlyOwner` maintenance operations. This gives time for users of the\\n * controlled contract to exit before a potentially dangerous maintenance\\n * operation is applied.\\n *\\n * By default, this contract is self administered, meaning administration tasks\\n * have to go through the timelock process. The proposer (resp executor) role\\n * is in charge of proposing (resp executing) operations. A common use case is\\n * to position this {TimelockController} as the owner of a smart contract, with\\n * a multisig or a DAO as the sole proposer.\\n */\\ncontract TimelockControllerUpgradeable is Initializable, AccessControlUpgradeable, ERC721HolderUpgradeable, ERC1155HolderUpgradeable {\\n bytes32 public constant PROPOSER_ROLE = keccak256(\\\"PROPOSER_ROLE\\\");\\n bytes32 public constant EXECUTOR_ROLE = keccak256(\\\"EXECUTOR_ROLE\\\");\\n bytes32 public constant CANCELLER_ROLE = keccak256(\\\"CANCELLER_ROLE\\\");\\n uint256 internal constant _DONE_TIMESTAMP = uint256(1);\\n\\n /// @custom:storage-location erc7201:openzeppelin.storage.TimelockController\\n struct TimelockControllerStorage {\\n mapping(bytes32 id => uint256) _timestamps;\\n uint256 _minDelay;\\n }\\n\\n // keccak256(abi.encode(uint256(keccak256(\\\"openzeppelin.storage.TimelockController\\\")) - 1)) & ~bytes32(uint256(0xff))\\n bytes32 private constant TimelockControllerStorageLocation = 0x9a37c2aa9d186a0969ff8a8267bf4e07e864c2f2768f5040949e28a624fb3600;\\n\\n function _getTimelockControllerStorage() private pure returns (TimelockControllerStorage storage $) {\\n assembly {\\n $.slot := TimelockControllerStorageLocation\\n }\\n }\\n\\n enum OperationState {\\n Unset,\\n Waiting,\\n Ready,\\n Done\\n }\\n\\n /**\\n * @dev Mismatch between the parameters length for an operation call.\\n */\\n error TimelockInvalidOperationLength(uint256 targets, uint256 payloads, uint256 values);\\n\\n /**\\n * @dev The schedule operation doesn't meet the minimum delay.\\n */\\n error TimelockInsufficientDelay(uint256 delay, uint256 minDelay);\\n\\n /**\\n * @dev The current state of an operation is not as required.\\n * The `expectedStates` is a bitmap with the bits enabled for each OperationState enum position\\n * counting from right to left.\\n *\\n * See {_encodeStateBitmap}.\\n */\\n error TimelockUnexpectedOperationState(bytes32 operationId, bytes32 expectedStates);\\n\\n /**\\n * @dev The predecessor to an operation not yet done.\\n */\\n error TimelockUnexecutedPredecessor(bytes32 predecessorId);\\n\\n /**\\n * @dev The caller account is not authorized.\\n */\\n error TimelockUnauthorizedCaller(address caller);\\n\\n /**\\n * @dev Emitted when a call is scheduled as part of operation `id`.\\n */\\n event CallScheduled(\\n bytes32 indexed id,\\n uint256 indexed index,\\n address target,\\n uint256 value,\\n bytes data,\\n bytes32 predecessor,\\n uint256 delay\\n );\\n\\n /**\\n * @dev Emitted when a call is performed as part of operation `id`.\\n */\\n event CallExecuted(bytes32 indexed id, uint256 indexed index, address target, uint256 value, bytes data);\\n\\n /**\\n * @dev Emitted when new proposal is scheduled with non-zero salt.\\n */\\n event CallSalt(bytes32 indexed id, bytes32 salt);\\n\\n /**\\n * @dev Emitted when operation `id` is cancelled.\\n */\\n event Cancelled(bytes32 indexed id);\\n\\n /**\\n * @dev Emitted when the minimum delay for future operations is modified.\\n */\\n event MinDelayChange(uint256 oldDuration, uint256 newDuration);\\n\\n /**\\n * @dev Initializes the contract with the following parameters:\\n *\\n * - `minDelay`: initial minimum delay in seconds for operations\\n * - `proposers`: accounts to be granted proposer and canceller roles\\n * - `executors`: accounts to be granted executor role\\n * - `admin`: optional account to be granted admin role; disable with zero address\\n *\\n * IMPORTANT: The optional admin can aid with initial configuration of roles after deployment\\n * without being subject to delay, but this role should be subsequently renounced in favor of\\n * administration through timelocked proposals. Previous versions of this contract would assign\\n * this admin to the deployer automatically and should be renounced as well.\\n */\\n function __TimelockController_init(uint256 minDelay, address[] memory proposers, address[] memory executors, address admin) internal onlyInitializing {\\n __TimelockController_init_unchained(minDelay, proposers, executors, admin);\\n }\\n\\n function __TimelockController_init_unchained(uint256 minDelay, address[] memory proposers, address[] memory executors, address admin) internal onlyInitializing {\\n TimelockControllerStorage storage $ = _getTimelockControllerStorage();\\n // self administration\\n _grantRole(DEFAULT_ADMIN_ROLE, address(this));\\n\\n // optional admin\\n if (admin != address(0)) {\\n _grantRole(DEFAULT_ADMIN_ROLE, admin);\\n }\\n\\n // register proposers and cancellers\\n for (uint256 i = 0; i < proposers.length; ++i) {\\n _grantRole(PROPOSER_ROLE, proposers[i]);\\n _grantRole(CANCELLER_ROLE, proposers[i]);\\n }\\n\\n // register executors\\n for (uint256 i = 0; i < executors.length; ++i) {\\n _grantRole(EXECUTOR_ROLE, executors[i]);\\n }\\n\\n $._minDelay = minDelay;\\n emit MinDelayChange(0, minDelay);\\n }\\n\\n /**\\n * @dev Modifier to make a function callable only by a certain role. In\\n * addition to checking the sender's role, `address(0)` 's role is also\\n * considered. Granting a role to `address(0)` is equivalent to enabling\\n * this role for everyone.\\n */\\n modifier onlyRoleOrOpenRole(bytes32 role) {\\n if (!hasRole(role, address(0))) {\\n _checkRole(role, _msgSender());\\n }\\n _;\\n }\\n\\n /**\\n * @dev Contract might receive/hold ETH as part of the maintenance process.\\n */\\n receive() external payable {}\\n\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(\\n bytes4 interfaceId\\n ) public view virtual override(AccessControlUpgradeable, ERC1155HolderUpgradeable) returns (bool) {\\n return super.supportsInterface(interfaceId);\\n }\\n\\n /**\\n * @dev Returns whether an id corresponds to a registered operation. This\\n * includes both Waiting, Ready, and Done operations.\\n */\\n function isOperation(bytes32 id) public view returns (bool) {\\n return getOperationState(id) != OperationState.Unset;\\n }\\n\\n /**\\n * @dev Returns whether an operation is pending or not. Note that a \\\"pending\\\" operation may also be \\\"ready\\\".\\n */\\n function isOperationPending(bytes32 id) public view returns (bool) {\\n OperationState state = getOperationState(id);\\n return state == OperationState.Waiting || state == OperationState.Ready;\\n }\\n\\n /**\\n * @dev Returns whether an operation is ready for execution. Note that a \\\"ready\\\" operation is also \\\"pending\\\".\\n */\\n function isOperationReady(bytes32 id) public view returns (bool) {\\n return getOperationState(id) == OperationState.Ready;\\n }\\n\\n /**\\n * @dev Returns whether an operation is done or not.\\n */\\n function isOperationDone(bytes32 id) public view returns (bool) {\\n return getOperationState(id) == OperationState.Done;\\n }\\n\\n /**\\n * @dev Returns the timestamp at which an operation becomes ready (0 for\\n * unset operations, 1 for done operations).\\n */\\n function getTimestamp(bytes32 id) public view virtual returns (uint256) {\\n TimelockControllerStorage storage $ = _getTimelockControllerStorage();\\n return $._timestamps[id];\\n }\\n\\n /**\\n * @dev Returns operation state.\\n */\\n function getOperationState(bytes32 id) public view virtual returns (OperationState) {\\n uint256 timestamp = getTimestamp(id);\\n if (timestamp == 0) {\\n return OperationState.Unset;\\n } else if (timestamp == _DONE_TIMESTAMP) {\\n return OperationState.Done;\\n } else if (timestamp > block.timestamp) {\\n return OperationState.Waiting;\\n } else {\\n return OperationState.Ready;\\n }\\n }\\n\\n /**\\n * @dev Returns the minimum delay in seconds for an operation to become valid.\\n *\\n * This value can be changed by executing an operation that calls `updateDelay`.\\n */\\n function getMinDelay() public view virtual returns (uint256) {\\n TimelockControllerStorage storage $ = _getTimelockControllerStorage();\\n return $._minDelay;\\n }\\n\\n /**\\n * @dev Returns the identifier of an operation containing a single\\n * transaction.\\n */\\n function hashOperation(\\n address target,\\n uint256 value,\\n bytes calldata data,\\n bytes32 predecessor,\\n bytes32 salt\\n ) public pure virtual returns (bytes32) {\\n return keccak256(abi.encode(target, value, data, predecessor, salt));\\n }\\n\\n /**\\n * @dev Returns the identifier of an operation containing a batch of\\n * transactions.\\n */\\n function hashOperationBatch(\\n address[] calldata targets,\\n uint256[] calldata values,\\n bytes[] calldata payloads,\\n bytes32 predecessor,\\n bytes32 salt\\n ) public pure virtual returns (bytes32) {\\n return keccak256(abi.encode(targets, values, payloads, predecessor, salt));\\n }\\n\\n /**\\n * @dev Schedule an operation containing a single transaction.\\n *\\n * Emits {CallSalt} if salt is nonzero, and {CallScheduled}.\\n *\\n * Requirements:\\n *\\n * - the caller must have the 'proposer' role.\\n */\\n function schedule(\\n address target,\\n uint256 value,\\n bytes calldata data,\\n bytes32 predecessor,\\n bytes32 salt,\\n uint256 delay\\n ) public virtual onlyRole(PROPOSER_ROLE) {\\n bytes32 id = hashOperation(target, value, data, predecessor, salt);\\n _schedule(id, delay);\\n emit CallScheduled(id, 0, target, value, data, predecessor, delay);\\n if (salt != bytes32(0)) {\\n emit CallSalt(id, salt);\\n }\\n }\\n\\n /**\\n * @dev Schedule an operation containing a batch of transactions.\\n *\\n * Emits {CallSalt} if salt is nonzero, and one {CallScheduled} event per transaction in the batch.\\n *\\n * Requirements:\\n *\\n * - the caller must have the 'proposer' role.\\n */\\n function scheduleBatch(\\n address[] calldata targets,\\n uint256[] calldata values,\\n bytes[] calldata payloads,\\n bytes32 predecessor,\\n bytes32 salt,\\n uint256 delay\\n ) public virtual onlyRole(PROPOSER_ROLE) {\\n if (targets.length != values.length || targets.length != payloads.length) {\\n revert TimelockInvalidOperationLength(targets.length, payloads.length, values.length);\\n }\\n\\n bytes32 id = hashOperationBatch(targets, values, payloads, predecessor, salt);\\n _schedule(id, delay);\\n for (uint256 i = 0; i < targets.length; ++i) {\\n emit CallScheduled(id, i, targets[i], values[i], payloads[i], predecessor, delay);\\n }\\n if (salt != bytes32(0)) {\\n emit CallSalt(id, salt);\\n }\\n }\\n\\n /**\\n * @dev Schedule an operation that is to become valid after a given delay.\\n */\\n function _schedule(bytes32 id, uint256 delay) private {\\n TimelockControllerStorage storage $ = _getTimelockControllerStorage();\\n if (isOperation(id)) {\\n revert TimelockUnexpectedOperationState(id, _encodeStateBitmap(OperationState.Unset));\\n }\\n uint256 minDelay = getMinDelay();\\n if (delay < minDelay) {\\n revert TimelockInsufficientDelay(delay, minDelay);\\n }\\n $._timestamps[id] = block.timestamp + delay;\\n }\\n\\n /**\\n * @dev Cancel an operation.\\n *\\n * Requirements:\\n *\\n * - the caller must have the 'canceller' role.\\n */\\n function cancel(bytes32 id) public virtual onlyRole(CANCELLER_ROLE) {\\n TimelockControllerStorage storage $ = _getTimelockControllerStorage();\\n if (!isOperationPending(id)) {\\n revert TimelockUnexpectedOperationState(\\n id,\\n _encodeStateBitmap(OperationState.Waiting) | _encodeStateBitmap(OperationState.Ready)\\n );\\n }\\n delete $._timestamps[id];\\n\\n emit Cancelled(id);\\n }\\n\\n /**\\n * @dev Execute an (ready) operation containing a single transaction.\\n *\\n * Emits a {CallExecuted} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have the 'executor' role.\\n */\\n // This function can reenter, but it doesn't pose a risk because _afterCall checks that the proposal is pending,\\n // thus any modifications to the operation during reentrancy should be caught.\\n // slither-disable-next-line reentrancy-eth\\n function execute(\\n address target,\\n uint256 value,\\n bytes calldata payload,\\n bytes32 predecessor,\\n bytes32 salt\\n ) public payable virtual onlyRoleOrOpenRole(EXECUTOR_ROLE) {\\n bytes32 id = hashOperation(target, value, payload, predecessor, salt);\\n\\n _beforeCall(id, predecessor);\\n _execute(target, value, payload);\\n emit CallExecuted(id, 0, target, value, payload);\\n _afterCall(id);\\n }\\n\\n /**\\n * @dev Execute an (ready) operation containing a batch of transactions.\\n *\\n * Emits one {CallExecuted} event per transaction in the batch.\\n *\\n * Requirements:\\n *\\n * - the caller must have the 'executor' role.\\n */\\n // This function can reenter, but it doesn't pose a risk because _afterCall checks that the proposal is pending,\\n // thus any modifications to the operation during reentrancy should be caught.\\n // slither-disable-next-line reentrancy-eth\\n function executeBatch(\\n address[] calldata targets,\\n uint256[] calldata values,\\n bytes[] calldata payloads,\\n bytes32 predecessor,\\n bytes32 salt\\n ) public payable virtual onlyRoleOrOpenRole(EXECUTOR_ROLE) {\\n if (targets.length != values.length || targets.length != payloads.length) {\\n revert TimelockInvalidOperationLength(targets.length, payloads.length, values.length);\\n }\\n\\n bytes32 id = hashOperationBatch(targets, values, payloads, predecessor, salt);\\n\\n _beforeCall(id, predecessor);\\n for (uint256 i = 0; i < targets.length; ++i) {\\n address target = targets[i];\\n uint256 value = values[i];\\n bytes calldata payload = payloads[i];\\n _execute(target, value, payload);\\n emit CallExecuted(id, i, target, value, payload);\\n }\\n _afterCall(id);\\n }\\n\\n /**\\n * @dev Execute an operation's call.\\n */\\n function _execute(address target, uint256 value, bytes calldata data) internal virtual {\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n Address.verifyCallResult(success, returndata);\\n }\\n\\n /**\\n * @dev Checks before execution of an operation's calls.\\n */\\n function _beforeCall(bytes32 id, bytes32 predecessor) private view {\\n if (!isOperationReady(id)) {\\n revert TimelockUnexpectedOperationState(id, _encodeStateBitmap(OperationState.Ready));\\n }\\n if (predecessor != bytes32(0) && !isOperationDone(predecessor)) {\\n revert TimelockUnexecutedPredecessor(predecessor);\\n }\\n }\\n\\n /**\\n * @dev Checks after execution of an operation's calls.\\n */\\n function _afterCall(bytes32 id) private {\\n TimelockControllerStorage storage $ = _getTimelockControllerStorage();\\n if (!isOperationReady(id)) {\\n revert TimelockUnexpectedOperationState(id, _encodeStateBitmap(OperationState.Ready));\\n }\\n $._timestamps[id] = _DONE_TIMESTAMP;\\n }\\n\\n /**\\n * @dev Changes the minimum timelock duration for future operations.\\n *\\n * Emits a {MinDelayChange} event.\\n *\\n * Requirements:\\n *\\n * - the caller must be the timelock itself. This can only be achieved by scheduling and later executing\\n * an operation where the timelock is the target and the data is the ABI-encoded call to this function.\\n */\\n function updateDelay(uint256 newDelay) external virtual {\\n TimelockControllerStorage storage $ = _getTimelockControllerStorage();\\n address sender = _msgSender();\\n if (sender != address(this)) {\\n revert TimelockUnauthorizedCaller(sender);\\n }\\n emit MinDelayChange($._minDelay, newDelay);\\n $._minDelay = newDelay;\\n }\\n\\n /**\\n * @dev Encodes a `OperationState` into a `bytes32` representation where each bit enabled corresponds to\\n * the underlying position in the `OperationState` enum. For example:\\n *\\n * 0x000...1000\\n * ^^^^^^----- ...\\n * ^---- Done\\n * ^--- Ready\\n * ^-- Waiting\\n * ^- Unset\\n */\\n function _encodeStateBitmap(OperationState operationState) internal pure returns (bytes32) {\\n return bytes32(1 << uint8(operationState));\\n }\\n}\\n\",\"keccak256\":\"0xb75d85abe51db18b433c6a89548eefef59784504a2d0e775ed4e3b26d162c49b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/governance/extensions/GovernorCountingSimpleUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (governance/extensions/GovernorCountingSimple.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {GovernorUpgradeable} from \\\"../GovernorUpgradeable.sol\\\";\\nimport {Initializable} from \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Extension of {Governor} for simple, 3 options, vote counting.\\n */\\nabstract contract GovernorCountingSimpleUpgradeable is Initializable, GovernorUpgradeable {\\n /**\\n * @dev Supported vote types. Matches Governor Bravo ordering.\\n */\\n enum VoteType {\\n Against,\\n For,\\n Abstain\\n }\\n\\n struct ProposalVote {\\n uint256 againstVotes;\\n uint256 forVotes;\\n uint256 abstainVotes;\\n mapping(address voter => bool) hasVoted;\\n }\\n\\n /// @custom:storage-location erc7201:openzeppelin.storage.GovernorCountingSimple\\n struct GovernorCountingSimpleStorage {\\n mapping(uint256 proposalId => ProposalVote) _proposalVotes;\\n }\\n\\n // keccak256(abi.encode(uint256(keccak256(\\\"openzeppelin.storage.GovernorCountingSimple\\\")) - 1)) & ~bytes32(uint256(0xff))\\n bytes32 private constant GovernorCountingSimpleStorageLocation = 0xa1cefa0f43667ef127a258e673c94202a79b656e62899531c4376d87a7f39800;\\n\\n function _getGovernorCountingSimpleStorage() private pure returns (GovernorCountingSimpleStorage storage $) {\\n assembly {\\n $.slot := GovernorCountingSimpleStorageLocation\\n }\\n }\\n\\n function __GovernorCountingSimple_init() internal onlyInitializing {\\n }\\n\\n function __GovernorCountingSimple_init_unchained() internal onlyInitializing {\\n }\\n /**\\n * @dev See {IGovernor-COUNTING_MODE}.\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function COUNTING_MODE() public pure virtual override returns (string memory) {\\n return \\\"support=bravo&quorum=for,abstain\\\";\\n }\\n\\n /**\\n * @dev See {IGovernor-hasVoted}.\\n */\\n function hasVoted(uint256 proposalId, address account) public view virtual override returns (bool) {\\n GovernorCountingSimpleStorage storage $ = _getGovernorCountingSimpleStorage();\\n return $._proposalVotes[proposalId].hasVoted[account];\\n }\\n\\n /**\\n * @dev Accessor to the internal vote counts.\\n */\\n function proposalVotes(\\n uint256 proposalId\\n ) public view virtual returns (uint256 againstVotes, uint256 forVotes, uint256 abstainVotes) {\\n GovernorCountingSimpleStorage storage $ = _getGovernorCountingSimpleStorage();\\n ProposalVote storage proposalVote = $._proposalVotes[proposalId];\\n return (proposalVote.againstVotes, proposalVote.forVotes, proposalVote.abstainVotes);\\n }\\n\\n /**\\n * @dev See {Governor-_quorumReached}.\\n */\\n function _quorumReached(uint256 proposalId) internal view virtual override returns (bool) {\\n GovernorCountingSimpleStorage storage $ = _getGovernorCountingSimpleStorage();\\n ProposalVote storage proposalVote = $._proposalVotes[proposalId];\\n\\n return quorum(proposalSnapshot(proposalId)) <= proposalVote.forVotes + proposalVote.abstainVotes;\\n }\\n\\n /**\\n * @dev See {Governor-_voteSucceeded}. In this module, the forVotes must be strictly over the againstVotes.\\n */\\n function _voteSucceeded(uint256 proposalId) internal view virtual override returns (bool) {\\n GovernorCountingSimpleStorage storage $ = _getGovernorCountingSimpleStorage();\\n ProposalVote storage proposalVote = $._proposalVotes[proposalId];\\n\\n return proposalVote.forVotes > proposalVote.againstVotes;\\n }\\n\\n /**\\n * @dev See {Governor-_countVote}. In this module, the support follows the `VoteType` enum (from Governor Bravo).\\n */\\n function _countVote(\\n uint256 proposalId,\\n address account,\\n uint8 support,\\n uint256 weight,\\n bytes memory // params\\n ) internal virtual override {\\n GovernorCountingSimpleStorage storage $ = _getGovernorCountingSimpleStorage();\\n ProposalVote storage proposalVote = $._proposalVotes[proposalId];\\n\\n if (proposalVote.hasVoted[account]) {\\n revert GovernorAlreadyCastVote(account);\\n }\\n proposalVote.hasVoted[account] = true;\\n\\n if (support == uint8(VoteType.Against)) {\\n proposalVote.againstVotes += weight;\\n } else if (support == uint8(VoteType.For)) {\\n proposalVote.forVotes += weight;\\n } else if (support == uint8(VoteType.Abstain)) {\\n proposalVote.abstainVotes += weight;\\n } else {\\n revert GovernorInvalidVoteType();\\n }\\n }\\n}\\n\",\"keccak256\":\"0x52732e39a8a6f200bf40d8d13c2f00d00c10e6664db9e0f860350655c4a8f898\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/governance/extensions/GovernorSettingsUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (governance/extensions/GovernorSettings.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {GovernorUpgradeable} from \\\"../GovernorUpgradeable.sol\\\";\\nimport {Initializable} from \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Extension of {Governor} for settings updatable through governance.\\n */\\nabstract contract GovernorSettingsUpgradeable is Initializable, GovernorUpgradeable {\\n /// @custom:storage-location erc7201:openzeppelin.storage.GovernorSettings\\n struct GovernorSettingsStorage {\\n // amount of token\\n uint256 _proposalThreshold;\\n // timepoint: limited to uint48 in core (same as clock() type)\\n uint48 _votingDelay;\\n // duration: limited to uint32 in core\\n uint32 _votingPeriod;\\n }\\n\\n // keccak256(abi.encode(uint256(keccak256(\\\"openzeppelin.storage.GovernorSettings\\\")) - 1)) & ~bytes32(uint256(0xff))\\n bytes32 private constant GovernorSettingsStorageLocation = 0x00d7616c8fe29c6c2fbe1d0c5bc8f2faa4c35b43746e70b24b4d532752affd00;\\n\\n function _getGovernorSettingsStorage() private pure returns (GovernorSettingsStorage storage $) {\\n assembly {\\n $.slot := GovernorSettingsStorageLocation\\n }\\n }\\n\\n event VotingDelaySet(uint256 oldVotingDelay, uint256 newVotingDelay);\\n event VotingPeriodSet(uint256 oldVotingPeriod, uint256 newVotingPeriod);\\n event ProposalThresholdSet(uint256 oldProposalThreshold, uint256 newProposalThreshold);\\n\\n /**\\n * @dev Initialize the governance parameters.\\n */\\n function __GovernorSettings_init(uint48 initialVotingDelay, uint32 initialVotingPeriod, uint256 initialProposalThreshold) internal onlyInitializing {\\n __GovernorSettings_init_unchained(initialVotingDelay, initialVotingPeriod, initialProposalThreshold);\\n }\\n\\n function __GovernorSettings_init_unchained(uint48 initialVotingDelay, uint32 initialVotingPeriod, uint256 initialProposalThreshold) internal onlyInitializing {\\n _setVotingDelay(initialVotingDelay);\\n _setVotingPeriod(initialVotingPeriod);\\n _setProposalThreshold(initialProposalThreshold);\\n }\\n\\n /**\\n * @dev See {IGovernor-votingDelay}.\\n */\\n function votingDelay() public view virtual override returns (uint256) {\\n GovernorSettingsStorage storage $ = _getGovernorSettingsStorage();\\n return $._votingDelay;\\n }\\n\\n /**\\n * @dev See {IGovernor-votingPeriod}.\\n */\\n function votingPeriod() public view virtual override returns (uint256) {\\n GovernorSettingsStorage storage $ = _getGovernorSettingsStorage();\\n return $._votingPeriod;\\n }\\n\\n /**\\n * @dev See {Governor-proposalThreshold}.\\n */\\n function proposalThreshold() public view virtual override returns (uint256) {\\n GovernorSettingsStorage storage $ = _getGovernorSettingsStorage();\\n return $._proposalThreshold;\\n }\\n\\n /**\\n * @dev Update the voting delay. This operation can only be performed through a governance proposal.\\n *\\n * Emits a {VotingDelaySet} event.\\n */\\n function setVotingDelay(uint48 newVotingDelay) public virtual onlyGovernance {\\n _setVotingDelay(newVotingDelay);\\n }\\n\\n /**\\n * @dev Update the voting period. This operation can only be performed through a governance proposal.\\n *\\n * Emits a {VotingPeriodSet} event.\\n */\\n function setVotingPeriod(uint32 newVotingPeriod) public virtual onlyGovernance {\\n _setVotingPeriod(newVotingPeriod);\\n }\\n\\n /**\\n * @dev Update the proposal threshold. This operation can only be performed through a governance proposal.\\n *\\n * Emits a {ProposalThresholdSet} event.\\n */\\n function setProposalThreshold(uint256 newProposalThreshold) public virtual onlyGovernance {\\n _setProposalThreshold(newProposalThreshold);\\n }\\n\\n /**\\n * @dev Internal setter for the voting delay.\\n *\\n * Emits a {VotingDelaySet} event.\\n */\\n function _setVotingDelay(uint48 newVotingDelay) internal virtual {\\n GovernorSettingsStorage storage $ = _getGovernorSettingsStorage();\\n emit VotingDelaySet($._votingDelay, newVotingDelay);\\n $._votingDelay = newVotingDelay;\\n }\\n\\n /**\\n * @dev Internal setter for the voting period.\\n *\\n * Emits a {VotingPeriodSet} event.\\n */\\n function _setVotingPeriod(uint32 newVotingPeriod) internal virtual {\\n GovernorSettingsStorage storage $ = _getGovernorSettingsStorage();\\n if (newVotingPeriod == 0) {\\n revert GovernorInvalidVotingPeriod(0);\\n }\\n emit VotingPeriodSet($._votingPeriod, newVotingPeriod);\\n $._votingPeriod = newVotingPeriod;\\n }\\n\\n /**\\n * @dev Internal setter for the proposal threshold.\\n *\\n * Emits a {ProposalThresholdSet} event.\\n */\\n function _setProposalThreshold(uint256 newProposalThreshold) internal virtual {\\n GovernorSettingsStorage storage $ = _getGovernorSettingsStorage();\\n emit ProposalThresholdSet($._proposalThreshold, newProposalThreshold);\\n $._proposalThreshold = newProposalThreshold;\\n }\\n}\\n\",\"keccak256\":\"0x2bfac877022e16e6e607e8921c2f1eb1078750b8c9d679945f437dcc5cb9c086\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/governance/extensions/GovernorTimelockControlUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (governance/extensions/GovernorTimelockControl.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IGovernor} from \\\"@openzeppelin/contracts/governance/IGovernor.sol\\\";\\nimport {GovernorUpgradeable} from \\\"../GovernorUpgradeable.sol\\\";\\nimport {TimelockControllerUpgradeable} from \\\"../TimelockControllerUpgradeable.sol\\\";\\nimport {IERC165} from \\\"@openzeppelin/contracts/utils/introspection/IERC165.sol\\\";\\nimport {SafeCast} from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport {Initializable} from \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Extension of {Governor} that binds the execution process to an instance of {TimelockController}. This adds a\\n * delay, enforced by the {TimelockController} to all successful proposal (in addition to the voting duration). The\\n * {Governor} needs the proposer (and ideally the executor) roles for the {Governor} to work properly.\\n *\\n * Using this model means the proposal will be operated by the {TimelockController} and not by the {Governor}. Thus,\\n * the assets and permissions must be attached to the {TimelockController}. Any asset sent to the {Governor} will be\\n * inaccessible from a proposal, unless executed via {Governor-relay}.\\n *\\n * WARNING: Setting up the TimelockController to have additional proposers or cancellers besides the governor is very\\n * risky, as it grants them the ability to: 1) execute operations as the timelock, and thus possibly performing\\n * operations or accessing funds that are expected to only be accessible through a vote, and 2) block governance\\n * proposals that have been approved by the voters, effectively executing a Denial of Service attack.\\n *\\n * NOTE: `AccessManager` does not support scheduling more than one operation with the same target and calldata at\\n * the same time. See {AccessManager-schedule} for a workaround.\\n */\\nabstract contract GovernorTimelockControlUpgradeable is Initializable, GovernorUpgradeable {\\n /// @custom:storage-location erc7201:openzeppelin.storage.GovernorTimelockControl\\n struct GovernorTimelockControlStorage {\\n TimelockControllerUpgradeable _timelock;\\n mapping(uint256 proposalId => bytes32) _timelockIds;\\n }\\n\\n // keccak256(abi.encode(uint256(keccak256(\\\"openzeppelin.storage.GovernorTimelockControl\\\")) - 1)) & ~bytes32(uint256(0xff))\\n bytes32 private constant GovernorTimelockControlStorageLocation = 0x0d5829787b8befdbc6044ef7457d8a95c2a04bc99235349f1a212c063e59d400;\\n\\n function _getGovernorTimelockControlStorage() private pure returns (GovernorTimelockControlStorage storage $) {\\n assembly {\\n $.slot := GovernorTimelockControlStorageLocation\\n }\\n }\\n\\n /**\\n * @dev Emitted when the timelock controller used for proposal execution is modified.\\n */\\n event TimelockChange(address oldTimelock, address newTimelock);\\n\\n /**\\n * @dev Set the timelock.\\n */\\n function __GovernorTimelockControl_init(TimelockControllerUpgradeable timelockAddress) internal onlyInitializing {\\n __GovernorTimelockControl_init_unchained(timelockAddress);\\n }\\n\\n function __GovernorTimelockControl_init_unchained(TimelockControllerUpgradeable timelockAddress) internal onlyInitializing {\\n _updateTimelock(timelockAddress);\\n }\\n\\n /**\\n * @dev Overridden version of the {Governor-state} function that considers the status reported by the timelock.\\n */\\n function state(uint256 proposalId) public view virtual override returns (ProposalState) {\\n GovernorTimelockControlStorage storage $ = _getGovernorTimelockControlStorage();\\n ProposalState currentState = super.state(proposalId);\\n\\n if (currentState != ProposalState.Queued) {\\n return currentState;\\n }\\n\\n bytes32 queueid = $._timelockIds[proposalId];\\n if ($._timelock.isOperationPending(queueid)) {\\n return ProposalState.Queued;\\n } else if ($._timelock.isOperationDone(queueid)) {\\n // This can happen if the proposal is executed directly on the timelock.\\n return ProposalState.Executed;\\n } else {\\n // This can happen if the proposal is canceled directly on the timelock.\\n return ProposalState.Canceled;\\n }\\n }\\n\\n /**\\n * @dev Public accessor to check the address of the timelock\\n */\\n function timelock() public view virtual returns (address) {\\n GovernorTimelockControlStorage storage $ = _getGovernorTimelockControlStorage();\\n return address($._timelock);\\n }\\n\\n /**\\n * @dev See {IGovernor-proposalNeedsQueuing}.\\n */\\n function proposalNeedsQueuing(uint256) public view virtual override returns (bool) {\\n return true;\\n }\\n\\n /**\\n * @dev Function to queue a proposal to the timelock.\\n */\\n function _queueOperations(\\n uint256 proposalId,\\n address[] memory targets,\\n uint256[] memory values,\\n bytes[] memory calldatas,\\n bytes32 descriptionHash\\n ) internal virtual override returns (uint48) {\\n GovernorTimelockControlStorage storage $ = _getGovernorTimelockControlStorage();\\n uint256 delay = $._timelock.getMinDelay();\\n\\n bytes32 salt = _timelockSalt(descriptionHash);\\n $._timelockIds[proposalId] = $._timelock.hashOperationBatch(targets, values, calldatas, 0, salt);\\n $._timelock.scheduleBatch(targets, values, calldatas, 0, salt, delay);\\n\\n return SafeCast.toUint48(block.timestamp + delay);\\n }\\n\\n /**\\n * @dev Overridden version of the {Governor-_executeOperations} function that runs the already queued proposal\\n * through the timelock.\\n */\\n function _executeOperations(\\n uint256 proposalId,\\n address[] memory targets,\\n uint256[] memory values,\\n bytes[] memory calldatas,\\n bytes32 descriptionHash\\n ) internal virtual override {\\n GovernorTimelockControlStorage storage $ = _getGovernorTimelockControlStorage();\\n // execute\\n $._timelock.executeBatch{value: msg.value}(targets, values, calldatas, 0, _timelockSalt(descriptionHash));\\n // cleanup for refund\\n delete $._timelockIds[proposalId];\\n }\\n\\n /**\\n * @dev Overridden version of the {Governor-_cancel} function to cancel the timelocked proposal if it has already\\n * been queued.\\n */\\n // This function can reenter through the external call to the timelock, but we assume the timelock is trusted and\\n // well behaved (according to TimelockController) and this will not happen.\\n // slither-disable-next-line reentrancy-no-eth\\n function _cancel(\\n address[] memory targets,\\n uint256[] memory values,\\n bytes[] memory calldatas,\\n bytes32 descriptionHash\\n ) internal virtual override returns (uint256) {\\n GovernorTimelockControlStorage storage $ = _getGovernorTimelockControlStorage();\\n uint256 proposalId = super._cancel(targets, values, calldatas, descriptionHash);\\n\\n bytes32 timelockId = $._timelockIds[proposalId];\\n if (timelockId != 0) {\\n // cancel\\n $._timelock.cancel(timelockId);\\n // cleanup\\n delete $._timelockIds[proposalId];\\n }\\n\\n return proposalId;\\n }\\n\\n /**\\n * @dev Address through which the governor executes action. In this case, the timelock.\\n */\\n function _executor() internal view virtual override returns (address) {\\n GovernorTimelockControlStorage storage $ = _getGovernorTimelockControlStorage();\\n return address($._timelock);\\n }\\n\\n /**\\n * @dev Public endpoint to update the underlying timelock instance. Restricted to the timelock itself, so updates\\n * must be proposed, scheduled, and executed through governance proposals.\\n *\\n * CAUTION: It is not recommended to change the timelock while there are other queued governance proposals.\\n */\\n function updateTimelock(TimelockControllerUpgradeable newTimelock) external virtual onlyGovernance {\\n _updateTimelock(newTimelock);\\n }\\n\\n function _updateTimelock(TimelockControllerUpgradeable newTimelock) private {\\n GovernorTimelockControlStorage storage $ = _getGovernorTimelockControlStorage();\\n emit TimelockChange(address($._timelock), address(newTimelock));\\n $._timelock = newTimelock;\\n }\\n\\n /**\\n * @dev Computes the {TimelockController} operation salt.\\n *\\n * It is computed with the governor address itself to avoid collisions across governor instances using the\\n * same timelock.\\n */\\n function _timelockSalt(bytes32 descriptionHash) private view returns (bytes32) {\\n return bytes20(address(this)) ^ descriptionHash;\\n }\\n}\\n\",\"keccak256\":\"0xe73156cc9e2fae24760b70d1a9afe17f34071e11ef6fffe219f5bcf91f3855f6\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/governance/extensions/GovernorVotesQuorumFractionUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (governance/extensions/GovernorVotesQuorumFraction.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {GovernorVotesUpgradeable} from \\\"./GovernorVotesUpgradeable.sol\\\";\\nimport {SafeCast} from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport {Checkpoints} from \\\"@openzeppelin/contracts/utils/structs/Checkpoints.sol\\\";\\nimport {Initializable} from \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Extension of {Governor} for voting weight extraction from an {ERC20Votes} token and a quorum expressed as a\\n * fraction of the total supply.\\n */\\nabstract contract GovernorVotesQuorumFractionUpgradeable is Initializable, GovernorVotesUpgradeable {\\n using Checkpoints for Checkpoints.Trace208;\\n\\n /// @custom:storage-location erc7201:openzeppelin.storage.GovernorVotesQuorumFraction\\n struct GovernorVotesQuorumFractionStorage {\\n Checkpoints.Trace208 _quorumNumeratorHistory;\\n }\\n\\n // keccak256(abi.encode(uint256(keccak256(\\\"openzeppelin.storage.GovernorVotesQuorumFraction\\\")) - 1)) & ~bytes32(uint256(0xff))\\n bytes32 private constant GovernorVotesQuorumFractionStorageLocation = 0xe770710421fd2cad75ad828c61aa98f2d77d423a440b67872d0f65554148e000;\\n\\n function _getGovernorVotesQuorumFractionStorage() private pure returns (GovernorVotesQuorumFractionStorage storage $) {\\n assembly {\\n $.slot := GovernorVotesQuorumFractionStorageLocation\\n }\\n }\\n\\n event QuorumNumeratorUpdated(uint256 oldQuorumNumerator, uint256 newQuorumNumerator);\\n\\n /**\\n * @dev The quorum set is not a valid fraction.\\n */\\n error GovernorInvalidQuorumFraction(uint256 quorumNumerator, uint256 quorumDenominator);\\n\\n /**\\n * @dev Initialize quorum as a fraction of the token's total supply.\\n *\\n * The fraction is specified as `numerator / denominator`. By default the denominator is 100, so quorum is\\n * specified as a percent: a numerator of 10 corresponds to quorum being 10% of total supply. The denominator can be\\n * customized by overriding {quorumDenominator}.\\n */\\n function __GovernorVotesQuorumFraction_init(uint256 quorumNumeratorValue) internal onlyInitializing {\\n __GovernorVotesQuorumFraction_init_unchained(quorumNumeratorValue);\\n }\\n\\n function __GovernorVotesQuorumFraction_init_unchained(uint256 quorumNumeratorValue) internal onlyInitializing {\\n _updateQuorumNumerator(quorumNumeratorValue);\\n }\\n\\n /**\\n * @dev Returns the current quorum numerator. See {quorumDenominator}.\\n */\\n function quorumNumerator() public view virtual returns (uint256) {\\n GovernorVotesQuorumFractionStorage storage $ = _getGovernorVotesQuorumFractionStorage();\\n return $._quorumNumeratorHistory.latest();\\n }\\n\\n /**\\n * @dev Returns the quorum numerator at a specific timepoint. See {quorumDenominator}.\\n */\\n function quorumNumerator(uint256 timepoint) public view virtual returns (uint256) {\\n GovernorVotesQuorumFractionStorage storage $ = _getGovernorVotesQuorumFractionStorage();\\n uint256 length = $._quorumNumeratorHistory._checkpoints.length;\\n\\n // Optimistic search, check the latest checkpoint\\n Checkpoints.Checkpoint208 storage latest = $._quorumNumeratorHistory._checkpoints[length - 1];\\n uint48 latestKey = latest._key;\\n uint208 latestValue = latest._value;\\n if (latestKey <= timepoint) {\\n return latestValue;\\n }\\n\\n // Otherwise, do the binary search\\n return $._quorumNumeratorHistory.upperLookupRecent(SafeCast.toUint48(timepoint));\\n }\\n\\n /**\\n * @dev Returns the quorum denominator. Defaults to 100, but may be overridden.\\n */\\n function quorumDenominator() public view virtual returns (uint256) {\\n return 100;\\n }\\n\\n /**\\n * @dev Returns the quorum for a timepoint, in terms of number of votes: `supply * numerator / denominator`.\\n */\\n function quorum(uint256 timepoint) public view virtual override returns (uint256) {\\n return (token().getPastTotalSupply(timepoint) * quorumNumerator(timepoint)) / quorumDenominator();\\n }\\n\\n /**\\n * @dev Changes the quorum numerator.\\n *\\n * Emits a {QuorumNumeratorUpdated} event.\\n *\\n * Requirements:\\n *\\n * - Must be called through a governance proposal.\\n * - New numerator must be smaller or equal to the denominator.\\n */\\n function updateQuorumNumerator(uint256 newQuorumNumerator) external virtual onlyGovernance {\\n _updateQuorumNumerator(newQuorumNumerator);\\n }\\n\\n /**\\n * @dev Changes the quorum numerator.\\n *\\n * Emits a {QuorumNumeratorUpdated} event.\\n *\\n * Requirements:\\n *\\n * - New numerator must be smaller or equal to the denominator.\\n */\\n function _updateQuorumNumerator(uint256 newQuorumNumerator) internal virtual {\\n GovernorVotesQuorumFractionStorage storage $ = _getGovernorVotesQuorumFractionStorage();\\n uint256 denominator = quorumDenominator();\\n if (newQuorumNumerator > denominator) {\\n revert GovernorInvalidQuorumFraction(newQuorumNumerator, denominator);\\n }\\n\\n uint256 oldQuorumNumerator = quorumNumerator();\\n $._quorumNumeratorHistory.push(clock(), SafeCast.toUint208(newQuorumNumerator));\\n\\n emit QuorumNumeratorUpdated(oldQuorumNumerator, newQuorumNumerator);\\n }\\n}\\n\",\"keccak256\":\"0x56bef5c683c61ecb498f1d869f68c09d9f669a6d05113336f6fcd54213d05766\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/governance/extensions/GovernorVotesUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (governance/extensions/GovernorVotes.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {GovernorUpgradeable} from \\\"../GovernorUpgradeable.sol\\\";\\nimport {IVotes} from \\\"@openzeppelin/contracts/governance/utils/IVotes.sol\\\";\\nimport {IERC5805} from \\\"@openzeppelin/contracts/interfaces/IERC5805.sol\\\";\\nimport {SafeCast} from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport {Time} from \\\"@openzeppelin/contracts/utils/types/Time.sol\\\";\\nimport {Initializable} from \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Extension of {Governor} for voting weight extraction from an {ERC20Votes} token, or since v4.5 an {ERC721Votes}\\n * token.\\n */\\nabstract contract GovernorVotesUpgradeable is Initializable, GovernorUpgradeable {\\n /// @custom:storage-location erc7201:openzeppelin.storage.GovernorVotes\\n struct GovernorVotesStorage {\\n IERC5805 _token;\\n }\\n\\n // keccak256(abi.encode(uint256(keccak256(\\\"openzeppelin.storage.GovernorVotes\\\")) - 1)) & ~bytes32(uint256(0xff))\\n bytes32 private constant GovernorVotesStorageLocation = 0x3ba4977254e415696610a40ebf2258dbfa0ec6a2ff64e84bfe715ff16977cc00;\\n\\n function _getGovernorVotesStorage() private pure returns (GovernorVotesStorage storage $) {\\n assembly {\\n $.slot := GovernorVotesStorageLocation\\n }\\n }\\n\\n function __GovernorVotes_init(IVotes tokenAddress) internal onlyInitializing {\\n __GovernorVotes_init_unchained(tokenAddress);\\n }\\n\\n function __GovernorVotes_init_unchained(IVotes tokenAddress) internal onlyInitializing {\\n GovernorVotesStorage storage $ = _getGovernorVotesStorage();\\n $._token = IERC5805(address(tokenAddress));\\n }\\n\\n /**\\n * @dev The token that voting power is sourced from.\\n */\\n function token() public view virtual returns (IERC5805) {\\n GovernorVotesStorage storage $ = _getGovernorVotesStorage();\\n return $._token;\\n }\\n\\n /**\\n * @dev Clock (as specified in EIP-6372) is set to match the token's clock. Fallback to block numbers if the token\\n * does not implement EIP-6372.\\n */\\n function clock() public view virtual override returns (uint48) {\\n try token().clock() returns (uint48 timepoint) {\\n return timepoint;\\n } catch {\\n return Time.blockNumber();\\n }\\n }\\n\\n /**\\n * @dev Machine-readable description of the clock as specified in EIP-6372.\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function CLOCK_MODE() public view virtual override returns (string memory) {\\n try token().CLOCK_MODE() returns (string memory clockmode) {\\n return clockmode;\\n } catch {\\n return \\\"mode=blocknumber&from=default\\\";\\n }\\n }\\n\\n /**\\n * Read the voting weight from the token's built in snapshot mechanism (see {Governor-_getVotes}).\\n */\\n function _getVotes(\\n address account,\\n uint256 timepoint,\\n bytes memory /*params*/\\n ) internal view virtual override returns (uint256) {\\n return token().getPastVotes(account, timepoint);\\n }\\n}\\n\",\"keccak256\":\"0x9bfdec1fff789c3a2af0d3963ab525b8ec6ee8871e609f7d1d7acf9a07c236b8\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/governance/utils/VotesUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (governance/utils/Votes.sol)\\npragma solidity ^0.8.20;\\n\\nimport {IERC5805} from \\\"@openzeppelin/contracts/interfaces/IERC5805.sol\\\";\\nimport {ContextUpgradeable} from \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport {NoncesUpgradeable} from \\\"../../utils/NoncesUpgradeable.sol\\\";\\nimport {EIP712Upgradeable} from \\\"../../utils/cryptography/EIP712Upgradeable.sol\\\";\\nimport {Checkpoints} from \\\"@openzeppelin/contracts/utils/structs/Checkpoints.sol\\\";\\nimport {SafeCast} from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport {ECDSA} from \\\"@openzeppelin/contracts/utils/cryptography/ECDSA.sol\\\";\\nimport {Time} from \\\"@openzeppelin/contracts/utils/types/Time.sol\\\";\\nimport {Initializable} from \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev This is a base abstract contract that tracks voting units, which are a measure of voting power that can be\\n * transferred, and provides a system of vote delegation, where an account can delegate its voting units to a sort of\\n * \\\"representative\\\" that will pool delegated voting units from different accounts and can then use it to vote in\\n * decisions. In fact, voting units _must_ be delegated in order to count as actual votes, and an account has to\\n * delegate those votes to itself if it wishes to participate in decisions and does not have a trusted representative.\\n *\\n * This contract is often combined with a token contract such that voting units correspond to token units. For an\\n * example, see {ERC721Votes}.\\n *\\n * The full history of delegate votes is tracked on-chain so that governance protocols can consider votes as distributed\\n * at a particular block number to protect against flash loans and double voting. The opt-in delegate system makes the\\n * cost of this history tracking optional.\\n *\\n * When using this module the derived contract must implement {_getVotingUnits} (for example, make it return\\n * {ERC721-balanceOf}), and can use {_transferVotingUnits} to track a change in the distribution of those units (in the\\n * previous example, it would be included in {ERC721-_update}).\\n */\\nabstract contract VotesUpgradeable is Initializable, ContextUpgradeable, EIP712Upgradeable, NoncesUpgradeable, IERC5805 {\\n using Checkpoints for Checkpoints.Trace208;\\n\\n bytes32 private constant DELEGATION_TYPEHASH =\\n keccak256(\\\"Delegation(address delegatee,uint256 nonce,uint256 expiry)\\\");\\n\\n /// @custom:storage-location erc7201:openzeppelin.storage.Votes\\n struct VotesStorage {\\n mapping(address account => address) _delegatee;\\n\\n mapping(address delegatee => Checkpoints.Trace208) _delegateCheckpoints;\\n\\n Checkpoints.Trace208 _totalCheckpoints;\\n }\\n\\n // keccak256(abi.encode(uint256(keccak256(\\\"openzeppelin.storage.Votes\\\")) - 1)) & ~bytes32(uint256(0xff))\\n bytes32 private constant VotesStorageLocation = 0xe8b26c30fad74198956032a3533d903385d56dd795af560196f9c78d4af40d00;\\n\\n function _getVotesStorage() private pure returns (VotesStorage storage $) {\\n assembly {\\n $.slot := VotesStorageLocation\\n }\\n }\\n\\n /**\\n * @dev The clock was incorrectly modified.\\n */\\n error ERC6372InconsistentClock();\\n\\n /**\\n * @dev Lookup to future votes is not available.\\n */\\n error ERC5805FutureLookup(uint256 timepoint, uint48 clock);\\n\\n function __Votes_init() internal onlyInitializing {\\n }\\n\\n function __Votes_init_unchained() internal onlyInitializing {\\n }\\n /**\\n * @dev Clock used for flagging checkpoints. Can be overridden to implement timestamp based\\n * checkpoints (and voting), in which case {CLOCK_MODE} should be overridden as well to match.\\n */\\n function clock() public view virtual returns (uint48) {\\n return Time.blockNumber();\\n }\\n\\n /**\\n * @dev Machine-readable description of the clock as specified in EIP-6372.\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function CLOCK_MODE() public view virtual returns (string memory) {\\n // Check that the clock was not modified\\n if (clock() != Time.blockNumber()) {\\n revert ERC6372InconsistentClock();\\n }\\n return \\\"mode=blocknumber&from=default\\\";\\n }\\n\\n /**\\n * @dev Returns the current amount of votes that `account` has.\\n */\\n function getVotes(address account) public view virtual returns (uint256) {\\n VotesStorage storage $ = _getVotesStorage();\\n return $._delegateCheckpoints[account].latest();\\n }\\n\\n /**\\n * @dev Returns the amount of votes that `account` had at a specific moment in the past. If the `clock()` is\\n * configured to use block numbers, this will return the value at the end of the corresponding block.\\n *\\n * Requirements:\\n *\\n * - `timepoint` must be in the past. If operating using block numbers, the block must be already mined.\\n */\\n function getPastVotes(address account, uint256 timepoint) public view virtual returns (uint256) {\\n VotesStorage storage $ = _getVotesStorage();\\n uint48 currentTimepoint = clock();\\n if (timepoint >= currentTimepoint) {\\n revert ERC5805FutureLookup(timepoint, currentTimepoint);\\n }\\n return $._delegateCheckpoints[account].upperLookupRecent(SafeCast.toUint48(timepoint));\\n }\\n\\n /**\\n * @dev Returns the total supply of votes available at a specific moment in the past. If the `clock()` is\\n * configured to use block numbers, this will return the value at the end of the corresponding block.\\n *\\n * NOTE: This value is the sum of all available votes, which is not necessarily the sum of all delegated votes.\\n * Votes that have not been delegated are still part of total supply, even though they would not participate in a\\n * vote.\\n *\\n * Requirements:\\n *\\n * - `timepoint` must be in the past. If operating using block numbers, the block must be already mined.\\n */\\n function getPastTotalSupply(uint256 timepoint) public view virtual returns (uint256) {\\n VotesStorage storage $ = _getVotesStorage();\\n uint48 currentTimepoint = clock();\\n if (timepoint >= currentTimepoint) {\\n revert ERC5805FutureLookup(timepoint, currentTimepoint);\\n }\\n return $._totalCheckpoints.upperLookupRecent(SafeCast.toUint48(timepoint));\\n }\\n\\n /**\\n * @dev Returns the current total supply of votes.\\n */\\n function _getTotalSupply() internal view virtual returns (uint256) {\\n VotesStorage storage $ = _getVotesStorage();\\n return $._totalCheckpoints.latest();\\n }\\n\\n /**\\n * @dev Returns the delegate that `account` has chosen.\\n */\\n function delegates(address account) public view virtual returns (address) {\\n VotesStorage storage $ = _getVotesStorage();\\n return $._delegatee[account];\\n }\\n\\n /**\\n * @dev Delegates votes from the sender to `delegatee`.\\n */\\n function delegate(address delegatee) public virtual {\\n address account = _msgSender();\\n _delegate(account, delegatee);\\n }\\n\\n /**\\n * @dev Delegates votes from signer to `delegatee`.\\n */\\n function delegateBySig(\\n address delegatee,\\n uint256 nonce,\\n uint256 expiry,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) public virtual {\\n if (block.timestamp > expiry) {\\n revert VotesExpiredSignature(expiry);\\n }\\n address signer = ECDSA.recover(\\n _hashTypedDataV4(keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry))),\\n v,\\n r,\\n s\\n );\\n _useCheckedNonce(signer, nonce);\\n _delegate(signer, delegatee);\\n }\\n\\n /**\\n * @dev Delegate all of `account`'s voting units to `delegatee`.\\n *\\n * Emits events {IVotes-DelegateChanged} and {IVotes-DelegateVotesChanged}.\\n */\\n function _delegate(address account, address delegatee) internal virtual {\\n VotesStorage storage $ = _getVotesStorage();\\n address oldDelegate = delegates(account);\\n $._delegatee[account] = delegatee;\\n\\n emit DelegateChanged(account, oldDelegate, delegatee);\\n _moveDelegateVotes(oldDelegate, delegatee, _getVotingUnits(account));\\n }\\n\\n /**\\n * @dev Transfers, mints, or burns voting units. To register a mint, `from` should be zero. To register a burn, `to`\\n * should be zero. Total supply of voting units will be adjusted with mints and burns.\\n */\\n function _transferVotingUnits(address from, address to, uint256 amount) internal virtual {\\n VotesStorage storage $ = _getVotesStorage();\\n if (from == address(0)) {\\n _push($._totalCheckpoints, _add, SafeCast.toUint208(amount));\\n }\\n if (to == address(0)) {\\n _push($._totalCheckpoints, _subtract, SafeCast.toUint208(amount));\\n }\\n _moveDelegateVotes(delegates(from), delegates(to), amount);\\n }\\n\\n /**\\n * @dev Moves delegated votes from one delegate to another.\\n */\\n function _moveDelegateVotes(address from, address to, uint256 amount) private {\\n VotesStorage storage $ = _getVotesStorage();\\n if (from != to && amount > 0) {\\n if (from != address(0)) {\\n (uint256 oldValue, uint256 newValue) = _push(\\n $._delegateCheckpoints[from],\\n _subtract,\\n SafeCast.toUint208(amount)\\n );\\n emit DelegateVotesChanged(from, oldValue, newValue);\\n }\\n if (to != address(0)) {\\n (uint256 oldValue, uint256 newValue) = _push(\\n $._delegateCheckpoints[to],\\n _add,\\n SafeCast.toUint208(amount)\\n );\\n emit DelegateVotesChanged(to, oldValue, newValue);\\n }\\n }\\n }\\n\\n /**\\n * @dev Get number of checkpoints for `account`.\\n */\\n function _numCheckpoints(address account) internal view virtual returns (uint32) {\\n VotesStorage storage $ = _getVotesStorage();\\n return SafeCast.toUint32($._delegateCheckpoints[account].length());\\n }\\n\\n /**\\n * @dev Get the `pos`-th checkpoint for `account`.\\n */\\n function _checkpoints(\\n address account,\\n uint32 pos\\n ) internal view virtual returns (Checkpoints.Checkpoint208 memory) {\\n VotesStorage storage $ = _getVotesStorage();\\n return $._delegateCheckpoints[account].at(pos);\\n }\\n\\n function _push(\\n Checkpoints.Trace208 storage store,\\n function(uint208, uint208) view returns (uint208) op,\\n uint208 delta\\n ) private returns (uint208, uint208) {\\n return store.push(clock(), op(store.latest(), delta));\\n }\\n\\n function _add(uint208 a, uint208 b) private pure returns (uint208) {\\n return a + b;\\n }\\n\\n function _subtract(uint208 a, uint208 b) private pure returns (uint208) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Must return the voting units held by an account.\\n */\\n function _getVotingUnits(address) internal view virtual returns (uint256);\\n}\\n\",\"keccak256\":\"0xa9db28430d1e949a78a2040f08ce0062b39f1ee436d2ca4f7bb3c99001ae0bc3\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\\n * reused. This mechanism prevents re-execution of each \\\"step\\\" but allows the creation of new initialization steps in\\n * case an upgrade adds a module that needs to be initialized.\\n *\\n * For example:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```solidity\\n * contract MyToken is ERC20Upgradeable {\\n * function initialize() initializer public {\\n * __ERC20_init(\\\"MyToken\\\", \\\"MTK\\\");\\n * }\\n * }\\n *\\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\\n * function initializeV2() reinitializer(2) public {\\n * __ERC20Permit_init(\\\"MyToken\\\");\\n * }\\n * }\\n * ```\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n *\\n * [CAUTION]\\n * ====\\n * Avoid leaving a contract uninitialized.\\n *\\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * /// @custom:oz-upgrades-unsafe-allow constructor\\n * constructor() {\\n * _disableInitializers();\\n * }\\n * ```\\n * ====\\n */\\nabstract contract Initializable {\\n /**\\n * @dev Storage of the initializable contract.\\n *\\n * It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions\\n * when using with upgradeable contracts.\\n *\\n * @custom:storage-location erc7201:openzeppelin.storage.Initializable\\n */\\n struct InitializableStorage {\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n uint64 _initialized;\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool _initializing;\\n }\\n\\n // keccak256(abi.encode(uint256(keccak256(\\\"openzeppelin.storage.Initializable\\\")) - 1)) & ~bytes32(uint256(0xff))\\n bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;\\n\\n /**\\n * @dev The contract is already initialized.\\n */\\n error InvalidInitialization();\\n\\n /**\\n * @dev The contract is not initializing.\\n */\\n error NotInitializing();\\n\\n /**\\n * @dev Triggered when the contract has been initialized or reinitialized.\\n */\\n event Initialized(uint64 version);\\n\\n /**\\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\\n * `onlyInitializing` functions can be used to initialize parent contracts.\\n *\\n * Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any\\n * number of times. This behavior in the constructor can be useful during testing and is not expected to be used in\\n * production.\\n *\\n * Emits an {Initialized} event.\\n */\\n modifier initializer() {\\n // solhint-disable-next-line var-name-mixedcase\\n InitializableStorage storage $ = _getInitializableStorage();\\n\\n // Cache values to avoid duplicated sloads\\n bool isTopLevelCall = !$._initializing;\\n uint64 initialized = $._initialized;\\n\\n // Allowed calls:\\n // - initialSetup: the contract is not in the initializing state and no previous version was\\n // initialized\\n // - construction: the contract is initialized at version 1 (no reininitialization) and the\\n // current contract is just being deployed\\n bool initialSetup = initialized == 0 && isTopLevelCall;\\n bool construction = initialized == 1 && address(this).code.length == 0;\\n\\n if (!initialSetup && !construction) {\\n revert InvalidInitialization();\\n }\\n $._initialized = 1;\\n if (isTopLevelCall) {\\n $._initializing = true;\\n }\\n _;\\n if (isTopLevelCall) {\\n $._initializing = false;\\n emit Initialized(1);\\n }\\n }\\n\\n /**\\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\\n * used to initialize parent contracts.\\n *\\n * A reinitializer may be used after the original initialization step. This is essential to configure modules that\\n * are added through upgrades and that require initialization.\\n *\\n * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\\n * cannot be nested. If one is invoked in the context of another, execution will revert.\\n *\\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\\n * a contract, executing them in the right order is up to the developer or operator.\\n *\\n * WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.\\n *\\n * Emits an {Initialized} event.\\n */\\n modifier reinitializer(uint64 version) {\\n // solhint-disable-next-line var-name-mixedcase\\n InitializableStorage storage $ = _getInitializableStorage();\\n\\n if ($._initializing || $._initialized >= version) {\\n revert InvalidInitialization();\\n }\\n $._initialized = version;\\n $._initializing = true;\\n _;\\n $._initializing = false;\\n emit Initialized(version);\\n }\\n\\n /**\\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\\n */\\n modifier onlyInitializing() {\\n _checkInitializing();\\n _;\\n }\\n\\n /**\\n * @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.\\n */\\n function _checkInitializing() internal view virtual {\\n if (!_isInitializing()) {\\n revert NotInitializing();\\n }\\n }\\n\\n /**\\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\\n * through proxies.\\n *\\n * Emits an {Initialized} event the first time it is successfully executed.\\n */\\n function _disableInitializers() internal virtual {\\n // solhint-disable-next-line var-name-mixedcase\\n InitializableStorage storage $ = _getInitializableStorage();\\n\\n if ($._initializing) {\\n revert InvalidInitialization();\\n }\\n if ($._initialized != type(uint64).max) {\\n $._initialized = type(uint64).max;\\n emit Initialized(type(uint64).max);\\n }\\n }\\n\\n /**\\n * @dev Returns the highest version that has been initialized. See {reinitializer}.\\n */\\n function _getInitializedVersion() internal view returns (uint64) {\\n return _getInitializableStorage()._initialized;\\n }\\n\\n /**\\n * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\\n */\\n function _isInitializing() internal view returns (bool) {\\n return _getInitializableStorage()._initializing;\\n }\\n\\n /**\\n * @dev Returns a pointer to the storage namespace.\\n */\\n // solhint-disable-next-line var-name-mixedcase\\n function _getInitializableStorage() private pure returns (InitializableStorage storage $) {\\n assembly {\\n $.slot := INITIALIZABLE_STORAGE\\n }\\n }\\n}\\n\",\"keccak256\":\"0x631188737069917d2f909d29ce62c4d48611d326686ba6683e26b72a23bfac0b\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/UUPSUpgradeable.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC1822Proxiable} from \\\"@openzeppelin/contracts/interfaces/draft-IERC1822.sol\\\";\\nimport {ERC1967Utils} from \\\"@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol\\\";\\nimport {Initializable} from \\\"./Initializable.sol\\\";\\n\\n/**\\n * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an\\n * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.\\n *\\n * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is\\n * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing\\n * `UUPSUpgradeable` with a custom implementation of upgrades.\\n *\\n * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.\\n */\\nabstract contract UUPSUpgradeable is Initializable, IERC1822Proxiable {\\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\\n address private immutable __self = address(this);\\n\\n /**\\n * @dev The version of the upgrade interface of the contract. If this getter is missing, both `upgradeTo(address)`\\n * and `upgradeToAndCall(address,bytes)` are present, and `upgradeTo` must be used if no function should be called,\\n * while `upgradeToAndCall` will invoke the `receive` function if the second argument is the empty byte string.\\n * If the getter returns `\\\"5.0.0\\\"`, only `upgradeToAndCall(address,bytes)` is present, and the second argument must\\n * be the empty byte string if no function should be called, making it impossible to invoke the `receive` function\\n * during an upgrade.\\n */\\n string public constant UPGRADE_INTERFACE_VERSION = \\\"5.0.0\\\";\\n\\n /**\\n * @dev The call is from an unauthorized context.\\n */\\n error UUPSUnauthorizedCallContext();\\n\\n /**\\n * @dev The storage `slot` is unsupported as a UUID.\\n */\\n error UUPSUnsupportedProxiableUUID(bytes32 slot);\\n\\n /**\\n * @dev Check that the execution is being performed through a delegatecall call and that the execution context is\\n * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case\\n * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a\\n * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to\\n * fail.\\n */\\n modifier onlyProxy() {\\n _checkProxy();\\n _;\\n }\\n\\n /**\\n * @dev Check that the execution is not being performed through a delegate call. This allows a function to be\\n * callable on the implementing contract but not through proxies.\\n */\\n modifier notDelegated() {\\n _checkNotDelegated();\\n _;\\n }\\n\\n function __UUPSUpgradeable_init() internal onlyInitializing {\\n }\\n\\n function __UUPSUpgradeable_init_unchained() internal onlyInitializing {\\n }\\n /**\\n * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the\\n * implementation. It is used to validate the implementation's compatibility when performing an upgrade.\\n *\\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\\n * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.\\n */\\n function proxiableUUID() external view virtual notDelegated returns (bytes32) {\\n return ERC1967Utils.IMPLEMENTATION_SLOT;\\n }\\n\\n /**\\n * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call\\n * encoded in `data`.\\n *\\n * Calls {_authorizeUpgrade}.\\n *\\n * Emits an {Upgraded} event.\\n *\\n * @custom:oz-upgrades-unsafe-allow-reachable delegatecall\\n */\\n function upgradeToAndCall(address newImplementation, bytes memory data) public payable virtual onlyProxy {\\n _authorizeUpgrade(newImplementation);\\n _upgradeToAndCallUUPS(newImplementation, data);\\n }\\n\\n /**\\n * @dev Reverts if the execution is not performed via delegatecall or the execution\\n * context is not of a proxy with an ERC1967-compliant implementation pointing to self.\\n * See {_onlyProxy}.\\n */\\n function _checkProxy() internal view virtual {\\n if (\\n address(this) == __self || // Must be called through delegatecall\\n ERC1967Utils.getImplementation() != __self // Must be called through an active proxy\\n ) {\\n revert UUPSUnauthorizedCallContext();\\n }\\n }\\n\\n /**\\n * @dev Reverts if the execution is performed via delegatecall.\\n * See {notDelegated}.\\n */\\n function _checkNotDelegated() internal view virtual {\\n if (address(this) != __self) {\\n // Must not be called through delegatecall\\n revert UUPSUnauthorizedCallContext();\\n }\\n }\\n\\n /**\\n * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by\\n * {upgradeToAndCall}.\\n *\\n * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.\\n *\\n * ```solidity\\n * function _authorizeUpgrade(address) internal onlyOwner {}\\n * ```\\n */\\n function _authorizeUpgrade(address newImplementation) internal virtual;\\n\\n /**\\n * @dev Performs an implementation upgrade with a security check for UUPS proxies, and additional setup call.\\n *\\n * As a security check, {proxiableUUID} is invoked in the new implementation, and the return value\\n * is expected to be the implementation slot in ERC1967.\\n *\\n * Emits an {IERC1967-Upgraded} event.\\n */\\n function _upgradeToAndCallUUPS(address newImplementation, bytes memory data) private {\\n try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {\\n if (slot != ERC1967Utils.IMPLEMENTATION_SLOT) {\\n revert UUPSUnsupportedProxiableUUID(slot);\\n }\\n ERC1967Utils.upgradeToAndCall(newImplementation, data);\\n } catch {\\n // The implementation is not UUPS\\n revert ERC1967Utils.ERC1967InvalidImplementation(newImplementation);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x3f13b947637c4969c0644cab4ef399cdc4b67f101463b8775c5a43b118558e53\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC1155/utils/ERC1155HolderUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/utils/ERC1155Holder.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC165} from \\\"@openzeppelin/contracts/utils/introspection/IERC165.sol\\\";\\nimport {ERC165Upgradeable} from \\\"../../../utils/introspection/ERC165Upgradeable.sol\\\";\\nimport {IERC1155Receiver} from \\\"@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol\\\";\\nimport {Initializable} from \\\"../../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Simple implementation of `IERC1155Receiver` that will allow a contract to hold ERC1155 tokens.\\n *\\n * IMPORTANT: When inheriting this contract, you must include a way to use the received tokens, otherwise they will be\\n * stuck.\\n */\\nabstract contract ERC1155HolderUpgradeable is Initializable, ERC165Upgradeable, IERC1155Receiver {\\n function __ERC1155Holder_init() internal onlyInitializing {\\n }\\n\\n function __ERC1155Holder_init_unchained() internal onlyInitializing {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165) returns (bool) {\\n return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId);\\n }\\n\\n function onERC1155Received(\\n address,\\n address,\\n uint256,\\n uint256,\\n bytes memory\\n ) public virtual override returns (bytes4) {\\n return this.onERC1155Received.selector;\\n }\\n\\n function onERC1155BatchReceived(\\n address,\\n address,\\n uint256[] memory,\\n uint256[] memory,\\n bytes memory\\n ) public virtual override returns (bytes4) {\\n return this.onERC1155BatchReceived.selector;\\n }\\n}\\n\",\"keccak256\":\"0xd5cd13424ae387f7356676f7b90081cc63af46eac66ef15efeaca6177863eb83\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/ERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport {IERC20Metadata} from \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\nimport {ContextUpgradeable} from \\\"../../utils/ContextUpgradeable.sol\\\";\\nimport {IERC20Errors} from \\\"@openzeppelin/contracts/interfaces/draft-IERC6093.sol\\\";\\nimport {Initializable} from \\\"../../proxy/utils/Initializable.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 *\\n * TIP: For a detailed writeup see our guide\\n * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How\\n * to implement supply mechanisms].\\n *\\n * The default value of {decimals} is 18. To change this, you should override\\n * this function so it returns a different value.\\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 */\\nabstract contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20, IERC20Metadata, IERC20Errors {\\n /// @custom:storage-location erc7201:openzeppelin.storage.ERC20\\n struct ERC20Storage {\\n mapping(address account => uint256) _balances;\\n\\n mapping(address account => mapping(address spender => uint256)) _allowances;\\n\\n uint256 _totalSupply;\\n\\n string _name;\\n string _symbol;\\n }\\n\\n // keccak256(abi.encode(uint256(keccak256(\\\"openzeppelin.storage.ERC20\\\")) - 1)) & ~bytes32(uint256(0xff))\\n bytes32 private constant ERC20StorageLocation = 0x52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace00;\\n\\n function _getERC20Storage() private pure returns (ERC20Storage storage $) {\\n assembly {\\n $.slot := ERC20StorageLocation\\n }\\n }\\n\\n /**\\n * @dev Sets the values for {name} and {symbol}.\\n *\\n * All two of these values are immutable: they can only be set once during\\n * construction.\\n */\\n function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {\\n __ERC20_init_unchained(name_, symbol_);\\n }\\n\\n function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {\\n ERC20Storage storage $ = _getERC20Storage();\\n $._name = name_;\\n $._symbol = symbol_;\\n }\\n\\n /**\\n * @dev Returns the name of the token.\\n */\\n function name() public view virtual returns (string memory) {\\n ERC20Storage storage $ = _getERC20Storage();\\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 returns (string memory) {\\n ERC20Storage storage $ = _getERC20Storage();\\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 default value returned by this function, unless\\n * it's 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 returns (uint8) {\\n return 18;\\n }\\n\\n /**\\n * @dev See {IERC20-totalSupply}.\\n */\\n function totalSupply() public view virtual returns (uint256) {\\n ERC20Storage storage $ = _getERC20Storage();\\n return $._totalSupply;\\n }\\n\\n /**\\n * @dev See {IERC20-balanceOf}.\\n */\\n function balanceOf(address account) public view virtual returns (uint256) {\\n ERC20Storage storage $ = _getERC20Storage();\\n return $._balances[account];\\n }\\n\\n /**\\n * @dev See {IERC20-transfer}.\\n *\\n * Requirements:\\n *\\n * - `to` cannot be the zero address.\\n * - the caller must have a balance of at least `value`.\\n */\\n function transfer(address to, uint256 value) public virtual returns (bool) {\\n address owner = _msgSender();\\n _transfer(owner, to, value);\\n return true;\\n }\\n\\n /**\\n * @dev See {IERC20-allowance}.\\n */\\n function allowance(address owner, address spender) public view virtual returns (uint256) {\\n ERC20Storage storage $ = _getERC20Storage();\\n return $._allowances[owner][spender];\\n }\\n\\n /**\\n * @dev See {IERC20-approve}.\\n *\\n * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on\\n * `transferFrom`. This is semantically equivalent to an infinite approval.\\n *\\n * Requirements:\\n *\\n * - `spender` cannot be the zero address.\\n */\\n function approve(address spender, uint256 value) public virtual returns (bool) {\\n address owner = _msgSender();\\n _approve(owner, spender, value);\\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 * NOTE: Does not update the allowance if the current allowance\\n * is the maximum `uint256`.\\n *\\n * Requirements:\\n *\\n * - `from` and `to` cannot be the zero address.\\n * - `from` must have a balance of at least `value`.\\n * - the caller must have allowance for ``from``'s tokens of at least\\n * `value`.\\n */\\n function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {\\n address spender = _msgSender();\\n _spendAllowance(from, spender, value);\\n _transfer(from, to, value);\\n return true;\\n }\\n\\n /**\\n * @dev Moves a `value` amount of tokens from `from` to `to`.\\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 * NOTE: This function is not virtual, {_update} should be overridden instead.\\n */\\n function _transfer(address from, address to, uint256 value) internal {\\n if (from == address(0)) {\\n revert ERC20InvalidSender(address(0));\\n }\\n if (to == address(0)) {\\n revert ERC20InvalidReceiver(address(0));\\n }\\n _update(from, to, value);\\n }\\n\\n /**\\n * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`\\n * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding\\n * this function.\\n *\\n * Emits a {Transfer} event.\\n */\\n function _update(address from, address to, uint256 value) internal virtual {\\n ERC20Storage storage $ = _getERC20Storage();\\n if (from == address(0)) {\\n // Overflow check required: The rest of the code assumes that totalSupply never overflows\\n $._totalSupply += value;\\n } else {\\n uint256 fromBalance = $._balances[from];\\n if (fromBalance < value) {\\n revert ERC20InsufficientBalance(from, fromBalance, value);\\n }\\n unchecked {\\n // Overflow not possible: value <= fromBalance <= totalSupply.\\n $._balances[from] = fromBalance - value;\\n }\\n }\\n\\n if (to == address(0)) {\\n unchecked {\\n // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.\\n $._totalSupply -= value;\\n }\\n } else {\\n unchecked {\\n // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.\\n $._balances[to] += value;\\n }\\n }\\n\\n emit Transfer(from, to, value);\\n }\\n\\n /**\\n * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).\\n * Relies on the `_update` mechanism\\n *\\n * Emits a {Transfer} event with `from` set to the zero address.\\n *\\n * NOTE: This function is not virtual, {_update} should be overridden instead.\\n */\\n function _mint(address account, uint256 value) internal {\\n if (account == address(0)) {\\n revert ERC20InvalidReceiver(address(0));\\n }\\n _update(address(0), account, value);\\n }\\n\\n /**\\n * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.\\n * Relies on the `_update` mechanism.\\n *\\n * Emits a {Transfer} event with `to` set to the zero address.\\n *\\n * NOTE: This function is not virtual, {_update} should be overridden instead\\n */\\n function _burn(address account, uint256 value) internal {\\n if (account == address(0)) {\\n revert ERC20InvalidSender(address(0));\\n }\\n _update(account, address(0), value);\\n }\\n\\n /**\\n * @dev Sets `value` 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 * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.\\n */\\n function _approve(address owner, address spender, uint256 value) internal {\\n _approve(owner, spender, value, true);\\n }\\n\\n /**\\n * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.\\n *\\n * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by\\n * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any\\n * `Approval` event during `transferFrom` operations.\\n *\\n * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to\\n * true using the following override:\\n * ```\\n * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {\\n * super._approve(owner, spender, value, true);\\n * }\\n * ```\\n *\\n * Requirements are the same as {_approve}.\\n */\\n function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {\\n ERC20Storage storage $ = _getERC20Storage();\\n if (owner == address(0)) {\\n revert ERC20InvalidApprover(address(0));\\n }\\n if (spender == address(0)) {\\n revert ERC20InvalidSpender(address(0));\\n }\\n $._allowances[owner][spender] = value;\\n if (emitEvent) {\\n emit Approval(owner, spender, value);\\n }\\n }\\n\\n /**\\n * @dev Updates `owner` s allowance for `spender` based on spent `value`.\\n *\\n * Does not update the allowance value in case of infinite allowance.\\n * Revert if not enough allowance is available.\\n *\\n * Does not emit an {Approval} event.\\n */\\n function _spendAllowance(address owner, address spender, uint256 value) internal virtual {\\n uint256 currentAllowance = allowance(owner, spender);\\n if (currentAllowance != type(uint256).max) {\\n if (currentAllowance < value) {\\n revert ERC20InsufficientAllowance(spender, currentAllowance, value);\\n }\\n unchecked {\\n _approve(owner, spender, currentAllowance - value, false);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x9a1766b1921bf91b3e61eb53c7a6e70725254befd4bdcbbcd3af40bd9f66856f\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20PermitUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/ERC20Permit.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20Permit} from \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol\\\";\\nimport {ERC20Upgradeable} from \\\"../ERC20Upgradeable.sol\\\";\\nimport {ECDSA} from \\\"@openzeppelin/contracts/utils/cryptography/ECDSA.sol\\\";\\nimport {EIP712Upgradeable} from \\\"../../../utils/cryptography/EIP712Upgradeable.sol\\\";\\nimport {NoncesUpgradeable} from \\\"../../../utils/NoncesUpgradeable.sol\\\";\\nimport {Initializable} from \\\"../../../proxy/utils/Initializable.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 */\\nabstract contract ERC20PermitUpgradeable is Initializable, ERC20Upgradeable, IERC20Permit, EIP712Upgradeable, NoncesUpgradeable {\\n bytes32 private constant PERMIT_TYPEHASH =\\n keccak256(\\\"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\\\");\\n\\n /**\\n * @dev Permit deadline has expired.\\n */\\n error ERC2612ExpiredSignature(uint256 deadline);\\n\\n /**\\n * @dev Mismatched signature.\\n */\\n error ERC2612InvalidSigner(address signer, address owner);\\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 function __ERC20Permit_init(string memory name) internal onlyInitializing {\\n __EIP712_init_unchained(name, \\\"1\\\");\\n }\\n\\n function __ERC20Permit_init_unchained(string memory) internal onlyInitializing {}\\n\\n /**\\n * @inheritdoc IERC20Permit\\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 if (block.timestamp > deadline) {\\n revert ERC2612ExpiredSignature(deadline);\\n }\\n\\n bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));\\n\\n bytes32 hash = _hashTypedDataV4(structHash);\\n\\n address signer = ECDSA.recover(hash, v, r, s);\\n if (signer != owner) {\\n revert ERC2612InvalidSigner(signer, owner);\\n }\\n\\n _approve(owner, spender, value);\\n }\\n\\n /**\\n * @inheritdoc IERC20Permit\\n */\\n function nonces(address owner) public view virtual override(IERC20Permit, NoncesUpgradeable) returns (uint256) {\\n return super.nonces(owner);\\n }\\n\\n /**\\n * @inheritdoc IERC20Permit\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function DOMAIN_SEPARATOR() external view virtual returns (bytes32) {\\n return _domainSeparatorV4();\\n }\\n}\\n\",\"keccak256\":\"0x8a97653aeba40e9f0c2e8df1a1379b29b927b6dc3534040c668e71ad9ae89d88\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20VotesUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/ERC20Votes.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {ERC20Upgradeable} from \\\"../ERC20Upgradeable.sol\\\";\\nimport {VotesUpgradeable} from \\\"../../../governance/utils/VotesUpgradeable.sol\\\";\\nimport {Checkpoints} from \\\"@openzeppelin/contracts/utils/structs/Checkpoints.sol\\\";\\nimport {Initializable} from \\\"../../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Extension of ERC20 to support Compound-like voting and delegation. This version is more generic than Compound's,\\n * and supports token supply up to 2^208^ - 1, while COMP is limited to 2^96^ - 1.\\n *\\n * NOTE: This contract does not provide interface compatibility with Compound's COMP token.\\n *\\n * This extension keeps a history (checkpoints) of each account's vote power. Vote power can be delegated either\\n * by calling the {delegate} function directly, or by providing a signature to be used with {delegateBySig}. Voting\\n * power can be queried through the public accessors {getVotes} and {getPastVotes}.\\n *\\n * By default, token balance does not account for voting power. This makes transfers cheaper. The downside is that it\\n * requires users to delegate to themselves in order to activate checkpoints and have their voting power tracked.\\n */\\nabstract contract ERC20VotesUpgradeable is Initializable, ERC20Upgradeable, VotesUpgradeable {\\n /**\\n * @dev Total supply cap has been exceeded, introducing a risk of votes overflowing.\\n */\\n error ERC20ExceededSafeSupply(uint256 increasedSupply, uint256 cap);\\n\\n function __ERC20Votes_init() internal onlyInitializing {\\n }\\n\\n function __ERC20Votes_init_unchained() internal onlyInitializing {\\n }\\n /**\\n * @dev Maximum token supply. Defaults to `type(uint208).max` (2^208^ - 1).\\n *\\n * This maximum is enforced in {_update}. It limits the total supply of the token, which is otherwise a uint256,\\n * so that checkpoints can be stored in the Trace208 structure used by {{Votes}}. Increasing this value will not\\n * remove the underlying limitation, and will cause {_update} to fail because of a math overflow in\\n * {_transferVotingUnits}. An override could be used to further restrict the total supply (to a lower value) if\\n * additional logic requires it. When resolving override conflicts on this function, the minimum should be\\n * returned.\\n */\\n function _maxSupply() internal view virtual returns (uint256) {\\n return type(uint208).max;\\n }\\n\\n /**\\n * @dev Move voting power when tokens are transferred.\\n *\\n * Emits a {IVotes-DelegateVotesChanged} event.\\n */\\n function _update(address from, address to, uint256 value) internal virtual override {\\n super._update(from, to, value);\\n if (from == address(0)) {\\n uint256 supply = totalSupply();\\n uint256 cap = _maxSupply();\\n if (supply > cap) {\\n revert ERC20ExceededSafeSupply(supply, cap);\\n }\\n }\\n _transferVotingUnits(from, to, value);\\n }\\n\\n /**\\n * @dev Returns the voting units of an `account`.\\n *\\n * WARNING: Overriding this function may compromise the internal vote accounting.\\n * `ERC20Votes` assumes tokens map to voting units 1:1 and this is not easy to change.\\n */\\n function _getVotingUnits(address account) internal view virtual override returns (uint256) {\\n return balanceOf(account);\\n }\\n\\n /**\\n * @dev Get number of checkpoints for `account`.\\n */\\n function numCheckpoints(address account) public view virtual returns (uint32) {\\n return _numCheckpoints(account);\\n }\\n\\n /**\\n * @dev Get the `pos`-th checkpoint for `account`.\\n */\\n function checkpoints(address account, uint32 pos) public view virtual returns (Checkpoints.Checkpoint208 memory) {\\n return _checkpoints(account, pos);\\n }\\n}\\n\",\"keccak256\":\"0x804fafbc589e3c29f075239c21a0f3ee8eff5bb5579cdd27992beb5126a050f2\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC721/utils/ERC721HolderUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/utils/ERC721Holder.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC721Receiver} from \\\"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol\\\";\\nimport {Initializable} from \\\"../../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC721Receiver} interface.\\n *\\n * Accepts all token transfers.\\n * Make sure the contract is able to use its token with {IERC721-safeTransferFrom}, {IERC721-approve} or\\n * {IERC721-setApprovalForAll}.\\n */\\nabstract contract ERC721HolderUpgradeable is Initializable, IERC721Receiver {\\n function __ERC721Holder_init() internal onlyInitializing {\\n }\\n\\n function __ERC721Holder_init_unchained() internal onlyInitializing {\\n }\\n /**\\n * @dev See {IERC721Receiver-onERC721Received}.\\n *\\n * Always returns `IERC721Receiver.onERC721Received.selector`.\\n */\\n function onERC721Received(address, address, uint256, bytes memory) public virtual returns (bytes4) {\\n return this.onERC721Received.selector;\\n }\\n}\\n\",\"keccak256\":\"0x9a4de3d90a92d682de7ec325eb3d032587fbe9782a4bbbf1b1fa72a82b2c06e3\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\\n\\npragma solidity ^0.8.20;\\nimport {Initializable} from \\\"../proxy/utils/Initializable.sol\\\";\\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 ContextUpgradeable is Initializable {\\n function __Context_init() internal onlyInitializing {\\n }\\n\\n function __Context_init_unchained() internal onlyInitializing {\\n }\\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 function _contextSuffixLength() internal view virtual returns (uint256) {\\n return 0;\\n }\\n}\\n\",\"keccak256\":\"0xdbef5f0c787055227243a7318ef74c8a5a1108ca3a07f2b3a00ef67769e1e397\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/NoncesUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Nonces.sol)\\npragma solidity ^0.8.20;\\nimport {Initializable} from \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Provides tracking nonces for addresses. Nonces will only increment.\\n */\\nabstract contract NoncesUpgradeable is Initializable {\\n /**\\n * @dev The nonce used for an `account` is not the expected current nonce.\\n */\\n error InvalidAccountNonce(address account, uint256 currentNonce);\\n\\n /// @custom:storage-location erc7201:openzeppelin.storage.Nonces\\n struct NoncesStorage {\\n mapping(address account => uint256) _nonces;\\n }\\n\\n // keccak256(abi.encode(uint256(keccak256(\\\"openzeppelin.storage.Nonces\\\")) - 1)) & ~bytes32(uint256(0xff))\\n bytes32 private constant NoncesStorageLocation = 0x5ab42ced628888259c08ac98db1eb0cf702fc1501344311d8b100cd1bfe4bb00;\\n\\n function _getNoncesStorage() private pure returns (NoncesStorage storage $) {\\n assembly {\\n $.slot := NoncesStorageLocation\\n }\\n }\\n\\n function __Nonces_init() internal onlyInitializing {\\n }\\n\\n function __Nonces_init_unchained() internal onlyInitializing {\\n }\\n /**\\n * @dev Returns the next unused nonce for an address.\\n */\\n function nonces(address owner) public view virtual returns (uint256) {\\n NoncesStorage storage $ = _getNoncesStorage();\\n return $._nonces[owner];\\n }\\n\\n /**\\n * @dev Consumes a nonce.\\n *\\n * Returns the current value and increments nonce.\\n */\\n function _useNonce(address owner) internal virtual returns (uint256) {\\n NoncesStorage storage $ = _getNoncesStorage();\\n // For each account, the nonce has an initial value of 0, can only be incremented by one, and cannot be\\n // decremented or reset. This guarantees that the nonce never overflows.\\n unchecked {\\n // It is important to do x++ and not ++x here.\\n return $._nonces[owner]++;\\n }\\n }\\n\\n /**\\n * @dev Same as {_useNonce} but checking that `nonce` is the next valid for `owner`.\\n */\\n function _useCheckedNonce(address owner, uint256 nonce) internal virtual {\\n uint256 current = _useNonce(owner);\\n if (nonce != current) {\\n revert InvalidAccountNonce(owner, current);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x778f4a1546a1c6c726ecc8e2348a2789690fb8f26e12bd9d89537669167b79a4\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/cryptography/EIP712Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/EIP712.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {MessageHashUtils} from \\\"@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol\\\";\\nimport {IERC5267} from \\\"@openzeppelin/contracts/interfaces/IERC5267.sol\\\";\\nimport {Initializable} from \\\"../../proxy/utils/Initializable.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 scheme specified in the EIP requires a domain separator and a hash of the typed structured data, whose\\n * encoding is very generic and therefore its implementation in Solidity is not feasible, thus this contract\\n * does not implement the encoding itself. Protocols need to implement the type-specific encoding they need in order to\\n * produce the hash of their typed data 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 * NOTE: In the upgradeable version of this contract, the cached values will correspond to the address, and the domain\\n * separator of the implementation contract. This will cause the {_domainSeparatorV4} function to always rebuild the\\n * separator from the immutable values, which is cheaper than accessing a cached version in cold storage.\\n */\\nabstract contract EIP712Upgradeable is Initializable, IERC5267 {\\n bytes32 private constant TYPE_HASH =\\n keccak256(\\\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\\\");\\n\\n /// @custom:storage-location erc7201:openzeppelin.storage.EIP712\\n struct EIP712Storage {\\n /// @custom:oz-renamed-from _HASHED_NAME\\n bytes32 _hashedName;\\n /// @custom:oz-renamed-from _HASHED_VERSION\\n bytes32 _hashedVersion;\\n\\n string _name;\\n string _version;\\n }\\n\\n // keccak256(abi.encode(uint256(keccak256(\\\"openzeppelin.storage.EIP712\\\")) - 1)) & ~bytes32(uint256(0xff))\\n bytes32 private constant EIP712StorageLocation = 0xa16a46d94261c7517cc8ff89f61c0ce93598e3c849801011dee649a6a557d100;\\n\\n function _getEIP712Storage() private pure returns (EIP712Storage storage $) {\\n assembly {\\n $.slot := EIP712StorageLocation\\n }\\n }\\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 function __EIP712_init(string memory name, string memory version) internal onlyInitializing {\\n __EIP712_init_unchained(name, version);\\n }\\n\\n function __EIP712_init_unchained(string memory name, string memory version) internal onlyInitializing {\\n EIP712Storage storage $ = _getEIP712Storage();\\n $._name = name;\\n $._version = version;\\n\\n // Reset prior values in storage if upgrading\\n $._hashedName = 0;\\n $._hashedVersion = 0;\\n }\\n\\n /**\\n * @dev Returns the domain separator for the current chain.\\n */\\n function _domainSeparatorV4() internal view returns (bytes32) {\\n return _buildDomainSeparator();\\n }\\n\\n function _buildDomainSeparator() private view returns (bytes32) {\\n return keccak256(abi.encode(TYPE_HASH, _EIP712NameHash(), _EIP712VersionHash(), block.chainid, address(this)));\\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) internal view virtual returns (bytes32) {\\n return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);\\n }\\n\\n /**\\n * @dev See {IERC-5267}.\\n */\\n function eip712Domain()\\n public\\n view\\n virtual\\n returns (\\n bytes1 fields,\\n string memory name,\\n string memory version,\\n uint256 chainId,\\n address verifyingContract,\\n bytes32 salt,\\n uint256[] memory extensions\\n )\\n {\\n EIP712Storage storage $ = _getEIP712Storage();\\n // If the hashed name and version in storage are non-zero, the contract hasn't been properly initialized\\n // and the EIP712 domain is not reliable, as it will be missing name and version.\\n require($._hashedName == 0 && $._hashedVersion == 0, \\\"EIP712: Uninitialized\\\");\\n\\n return (\\n hex\\\"0f\\\", // 01111\\n _EIP712Name(),\\n _EIP712Version(),\\n block.chainid,\\n address(this),\\n bytes32(0),\\n new uint256[](0)\\n );\\n }\\n\\n /**\\n * @dev The name parameter for the EIP712 domain.\\n *\\n * NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs\\n * are a concern.\\n */\\n function _EIP712Name() internal view virtual returns (string memory) {\\n EIP712Storage storage $ = _getEIP712Storage();\\n return $._name;\\n }\\n\\n /**\\n * @dev The version parameter for the EIP712 domain.\\n *\\n * NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs\\n * are a concern.\\n */\\n function _EIP712Version() internal view virtual returns (string memory) {\\n EIP712Storage storage $ = _getEIP712Storage();\\n return $._version;\\n }\\n\\n /**\\n * @dev The hash of the name parameter for the EIP712 domain.\\n *\\n * NOTE: In previous versions this function was virtual. In this version you should override `_EIP712Name` instead.\\n */\\n function _EIP712NameHash() internal view returns (bytes32) {\\n EIP712Storage storage $ = _getEIP712Storage();\\n string memory name = _EIP712Name();\\n if (bytes(name).length > 0) {\\n return keccak256(bytes(name));\\n } else {\\n // If the name is empty, the contract may have been upgraded without initializing the new storage.\\n // We return the name hash in storage if non-zero, otherwise we assume the name is empty by design.\\n bytes32 hashedName = $._hashedName;\\n if (hashedName != 0) {\\n return hashedName;\\n } else {\\n return keccak256(\\\"\\\");\\n }\\n }\\n }\\n\\n /**\\n * @dev The hash of the version parameter for the EIP712 domain.\\n *\\n * NOTE: In previous versions this function was virtual. In this version you should override `_EIP712Version` instead.\\n */\\n function _EIP712VersionHash() internal view returns (bytes32) {\\n EIP712Storage storage $ = _getEIP712Storage();\\n string memory version = _EIP712Version();\\n if (bytes(version).length > 0) {\\n return keccak256(bytes(version));\\n } else {\\n // If the version is empty, the contract may have been upgraded without initializing the new storage.\\n // We return the version hash in storage if non-zero, otherwise we assume the version is empty by design.\\n bytes32 hashedVersion = $._hashedVersion;\\n if (hashedVersion != 0) {\\n return hashedVersion;\\n } else {\\n return keccak256(\\\"\\\");\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x85462422a22578744581e012e9aa0a391958cb360288b0b63f29bf0431d70327\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC165} from \\\"@openzeppelin/contracts/utils/introspection/IERC165.sol\\\";\\nimport {Initializable} from \\\"../../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Implementation of the {IERC165} interface.\\n *\\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\\n * for the additional interface id that will be supported. For example:\\n *\\n * ```solidity\\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\\n * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\\n * }\\n * ```\\n */\\nabstract contract ERC165Upgradeable is Initializable, IERC165 {\\n function __ERC165_init() internal onlyInitializing {\\n }\\n\\n function __ERC165_init_unchained() internal onlyInitializing {\\n }\\n /**\\n * @dev See {IERC165-supportsInterface}.\\n */\\n function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {\\n return interfaceId == type(IERC165).interfaceId;\\n }\\n}\\n\",\"keccak256\":\"0xdaba3f7c42c55b2896353f32bd27d4d5f8bae741b3b05d4c53f67abc4dc47ce8\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/IAccessControl.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (access/IAccessControl.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev External interface of AccessControl declared to support ERC165 detection.\\n */\\ninterface IAccessControl {\\n /**\\n * @dev The `account` is missing a role.\\n */\\n error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);\\n\\n /**\\n * @dev The caller of a function is not the expected one.\\n *\\n * NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.\\n */\\n error AccessControlBadConfirmation();\\n\\n /**\\n * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\\n *\\n * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\\n * {RoleAdminChanged} not being emitted signaling this.\\n */\\n event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\\n\\n /**\\n * @dev Emitted when `account` is granted `role`.\\n *\\n * `sender` is the account that originated the contract call, an admin role\\n * bearer except when using {AccessControl-_setupRole}.\\n */\\n event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Emitted when `account` is revoked `role`.\\n *\\n * `sender` is the account that originated the contract call:\\n * - if using `revokeRole`, it is the admin role bearer\\n * - if using `renounceRole`, it is the role bearer (i.e. `account`)\\n */\\n event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\\n\\n /**\\n * @dev Returns `true` if `account` has been granted `role`.\\n */\\n function hasRole(bytes32 role, address account) external view returns (bool);\\n\\n /**\\n * @dev Returns the admin role that controls `role`. See {grantRole} and\\n * {revokeRole}.\\n *\\n * To change a role's admin, use {AccessControl-_setRoleAdmin}.\\n */\\n function getRoleAdmin(bytes32 role) external view returns (bytes32);\\n\\n /**\\n * @dev Grants `role` to `account`.\\n *\\n * If `account` had not been already granted `role`, emits a {RoleGranted}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function grantRole(bytes32 role, address account) external;\\n\\n /**\\n * @dev Revokes `role` from `account`.\\n *\\n * If `account` had been granted `role`, emits a {RoleRevoked} event.\\n *\\n * Requirements:\\n *\\n * - the caller must have ``role``'s admin role.\\n */\\n function revokeRole(bytes32 role, address account) external;\\n\\n /**\\n * @dev Revokes `role` from the calling account.\\n *\\n * Roles are often managed via {grantRole} and {revokeRole}: this function's\\n * purpose is to provide a mechanism for accounts to lose their privileges\\n * if they are compromised (such as when a trusted device is misplaced).\\n *\\n * If the calling account had been granted `role`, emits a {RoleRevoked}\\n * event.\\n *\\n * Requirements:\\n *\\n * - the caller must be `callerConfirmation`.\\n */\\n function renounceRole(bytes32 role, address callerConfirmation) external;\\n}\\n\",\"keccak256\":\"0xb6b36edd6a2999fd243ff226d6cbf84bd71af2432bbd0dfe19392996a1d9cb41\",\"license\":\"MIT\"},\"@openzeppelin/contracts/governance/IGovernor.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (governance/IGovernor.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC165} from \\\"../interfaces/IERC165.sol\\\";\\nimport {IERC6372} from \\\"../interfaces/IERC6372.sol\\\";\\n\\n/**\\n * @dev Interface of the {Governor} core.\\n */\\ninterface IGovernor is IERC165, IERC6372 {\\n enum ProposalState {\\n Pending,\\n Active,\\n Canceled,\\n Defeated,\\n Succeeded,\\n Queued,\\n Expired,\\n Executed\\n }\\n\\n /**\\n * @dev Empty proposal or a mismatch between the parameters length for a proposal call.\\n */\\n error GovernorInvalidProposalLength(uint256 targets, uint256 calldatas, uint256 values);\\n\\n /**\\n * @dev The vote was already cast.\\n */\\n error GovernorAlreadyCastVote(address voter);\\n\\n /**\\n * @dev Token deposits are disabled in this contract.\\n */\\n error GovernorDisabledDeposit();\\n\\n /**\\n * @dev The `account` is not a proposer.\\n */\\n error GovernorOnlyProposer(address account);\\n\\n /**\\n * @dev The `account` is not the governance executor.\\n */\\n error GovernorOnlyExecutor(address account);\\n\\n /**\\n * @dev The `proposalId` doesn't exist.\\n */\\n error GovernorNonexistentProposal(uint256 proposalId);\\n\\n /**\\n * @dev The current state of a proposal is not the required for performing an operation.\\n * The `expectedStates` is a bitmap with the bits enabled for each ProposalState enum position\\n * counting from right to left.\\n *\\n * NOTE: If `expectedState` is `bytes32(0)`, the proposal is expected to not be in any state (i.e. not exist).\\n * This is the case when a proposal that is expected to be unset is already initiated (the proposal is duplicated).\\n *\\n * See {Governor-_encodeStateBitmap}.\\n */\\n error GovernorUnexpectedProposalState(uint256 proposalId, ProposalState current, bytes32 expectedStates);\\n\\n /**\\n * @dev The voting period set is not a valid period.\\n */\\n error GovernorInvalidVotingPeriod(uint256 votingPeriod);\\n\\n /**\\n * @dev The `proposer` does not have the required votes to create a proposal.\\n */\\n error GovernorInsufficientProposerVotes(address proposer, uint256 votes, uint256 threshold);\\n\\n /**\\n * @dev The `proposer` is not allowed to create a proposal.\\n */\\n error GovernorRestrictedProposer(address proposer);\\n\\n /**\\n * @dev The vote type used is not valid for the corresponding counting module.\\n */\\n error GovernorInvalidVoteType();\\n\\n /**\\n * @dev Queue operation is not implemented for this governor. Execute should be called directly.\\n */\\n error GovernorQueueNotImplemented();\\n\\n /**\\n * @dev The proposal hasn't been queued yet.\\n */\\n error GovernorNotQueuedProposal(uint256 proposalId);\\n\\n /**\\n * @dev The proposal has already been queued.\\n */\\n error GovernorAlreadyQueuedProposal(uint256 proposalId);\\n\\n /**\\n * @dev The provided signature is not valid for the expected `voter`.\\n * If the `voter` is a contract, the signature is not valid using {IERC1271-isValidSignature}.\\n */\\n error GovernorInvalidSignature(address voter);\\n\\n /**\\n * @dev Emitted when a proposal is created.\\n */\\n event ProposalCreated(\\n uint256 proposalId,\\n address proposer,\\n address[] targets,\\n uint256[] values,\\n string[] signatures,\\n bytes[] calldatas,\\n uint256 voteStart,\\n uint256 voteEnd,\\n string description\\n );\\n\\n /**\\n * @dev Emitted when a proposal is queued.\\n */\\n event ProposalQueued(uint256 proposalId, uint256 etaSeconds);\\n\\n /**\\n * @dev Emitted when a proposal is executed.\\n */\\n event ProposalExecuted(uint256 proposalId);\\n\\n /**\\n * @dev Emitted when a proposal is canceled.\\n */\\n event ProposalCanceled(uint256 proposalId);\\n\\n /**\\n * @dev Emitted when a vote is cast without params.\\n *\\n * Note: `support` values should be seen as buckets. Their interpretation depends on the voting module used.\\n */\\n event VoteCast(address indexed voter, uint256 proposalId, uint8 support, uint256 weight, string reason);\\n\\n /**\\n * @dev Emitted when a vote is cast with params.\\n *\\n * Note: `support` values should be seen as buckets. Their interpretation depends on the voting module used.\\n * `params` are additional encoded parameters. Their interpepretation also depends on the voting module used.\\n */\\n event VoteCastWithParams(\\n address indexed voter,\\n uint256 proposalId,\\n uint8 support,\\n uint256 weight,\\n string reason,\\n bytes params\\n );\\n\\n /**\\n * @notice module:core\\n * @dev Name of the governor instance (used in building the ERC712 domain separator).\\n */\\n function name() external view returns (string memory);\\n\\n /**\\n * @notice module:core\\n * @dev Version of the governor instance (used in building the ERC712 domain separator). Default: \\\"1\\\"\\n */\\n function version() external view returns (string memory);\\n\\n /**\\n * @notice module:voting\\n * @dev A description of the possible `support` values for {castVote} and the way these votes are counted, meant to\\n * be consumed by UIs to show correct vote options and interpret the results. The string is a URL-encoded sequence of\\n * key-value pairs that each describe one aspect, for example `support=bravo&quorum=for,abstain`.\\n *\\n * There are 2 standard keys: `support` and `quorum`.\\n *\\n * - `support=bravo` refers to the vote options 0 = Against, 1 = For, 2 = Abstain, as in `GovernorBravo`.\\n * - `quorum=bravo` means that only For votes are counted towards quorum.\\n * - `quorum=for,abstain` means that both For and Abstain votes are counted towards quorum.\\n *\\n * If a counting module makes use of encoded `params`, it should include this under a `params` key with a unique\\n * name that describes the behavior. For example:\\n *\\n * - `params=fractional` might refer to a scheme where votes are divided fractionally between for/against/abstain.\\n * - `params=erc721` might refer to a scheme where specific NFTs are delegated to vote.\\n *\\n * NOTE: The string can be decoded by the standard\\n * https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams[`URLSearchParams`]\\n * JavaScript class.\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function COUNTING_MODE() external view returns (string memory);\\n\\n /**\\n * @notice module:core\\n * @dev Hashing function used to (re)build the proposal id from the proposal details..\\n */\\n function hashProposal(\\n address[] memory targets,\\n uint256[] memory values,\\n bytes[] memory calldatas,\\n bytes32 descriptionHash\\n ) external pure returns (uint256);\\n\\n /**\\n * @notice module:core\\n * @dev Current state of a proposal, following Compound's convention\\n */\\n function state(uint256 proposalId) external view returns (ProposalState);\\n\\n /**\\n * @notice module:core\\n * @dev The number of votes required in order for a voter to become a proposer.\\n */\\n function proposalThreshold() external view returns (uint256);\\n\\n /**\\n * @notice module:core\\n * @dev Timepoint used to retrieve user's votes and quorum. If using block number (as per Compound's Comp), the\\n * snapshot is performed at the end of this block. Hence, voting for this proposal starts at the beginning of the\\n * following block.\\n */\\n function proposalSnapshot(uint256 proposalId) external view returns (uint256);\\n\\n /**\\n * @notice module:core\\n * @dev Timepoint at which votes close. If using block number, votes close at the end of this block, so it is\\n * possible to cast a vote during this block.\\n */\\n function proposalDeadline(uint256 proposalId) external view returns (uint256);\\n\\n /**\\n * @notice module:core\\n * @dev The account that created a proposal.\\n */\\n function proposalProposer(uint256 proposalId) external view returns (address);\\n\\n /**\\n * @notice module:core\\n * @dev The time when a queued proposal becomes executable (\\\"ETA\\\"). Unlike {proposalSnapshot} and\\n * {proposalDeadline}, this doesn't use the governor clock, and instead relies on the executor's clock which may be\\n * different. In most cases this will be a timestamp.\\n */\\n function proposalEta(uint256 proposalId) external view returns (uint256);\\n\\n /**\\n * @notice module:core\\n * @dev Whether a proposal needs to be queued before execution.\\n */\\n function proposalNeedsQueuing(uint256 proposalId) external view returns (bool);\\n\\n /**\\n * @notice module:user-config\\n * @dev Delay, between the proposal is created and the vote starts. The unit this duration is expressed in depends\\n * on the clock (see EIP-6372) this contract uses.\\n *\\n * This can be increased to leave time for users to buy voting power, or delegate it, before the voting of a\\n * proposal starts.\\n *\\n * NOTE: While this interface returns a uint256, timepoints are stored as uint48 following the ERC-6372 clock type.\\n * Consequently this value must fit in a uint48 (when added to the current clock). See {IERC6372-clock}.\\n */\\n function votingDelay() external view returns (uint256);\\n\\n /**\\n * @notice module:user-config\\n * @dev Delay between the vote start and vote end. The unit this duration is expressed in depends on the clock\\n * (see EIP-6372) this contract uses.\\n *\\n * NOTE: The {votingDelay} can delay the start of the vote. This must be considered when setting the voting\\n * duration compared to the voting delay.\\n *\\n * NOTE: This value is stored when the proposal is submitted so that possible changes to the value do not affect\\n * proposals that have already been submitted. The type used to save it is a uint32. Consequently, while this\\n * interface returns a uint256, the value it returns should fit in a uint32.\\n */\\n function votingPeriod() external view returns (uint256);\\n\\n /**\\n * @notice module:user-config\\n * @dev Minimum number of cast voted required for a proposal to be successful.\\n *\\n * NOTE: The `timepoint` parameter corresponds to the snapshot used for counting vote. This allows to scale the\\n * quorum depending on values such as the totalSupply of a token at this timepoint (see {ERC20Votes}).\\n */\\n function quorum(uint256 timepoint) external view returns (uint256);\\n\\n /**\\n * @notice module:reputation\\n * @dev Voting power of an `account` at a specific `timepoint`.\\n *\\n * Note: this can be implemented in a number of ways, for example by reading the delegated balance from one (or\\n * multiple), {ERC20Votes} tokens.\\n */\\n function getVotes(address account, uint256 timepoint) external view returns (uint256);\\n\\n /**\\n * @notice module:reputation\\n * @dev Voting power of an `account` at a specific `timepoint` given additional encoded parameters.\\n */\\n function getVotesWithParams(\\n address account,\\n uint256 timepoint,\\n bytes memory params\\n ) external view returns (uint256);\\n\\n /**\\n * @notice module:voting\\n * @dev Returns whether `account` has cast a vote on `proposalId`.\\n */\\n function hasVoted(uint256 proposalId, address account) external view returns (bool);\\n\\n /**\\n * @dev Create a new proposal. Vote start after a delay specified by {IGovernor-votingDelay} and lasts for a\\n * duration specified by {IGovernor-votingPeriod}.\\n *\\n * Emits a {ProposalCreated} event.\\n */\\n function propose(\\n address[] memory targets,\\n uint256[] memory values,\\n bytes[] memory calldatas,\\n string memory description\\n ) external returns (uint256 proposalId);\\n\\n /**\\n * @dev Queue a proposal. Some governors require this step to be performed before execution can happen. If queuing\\n * is not necessary, this function may revert.\\n * Queuing a proposal requires the quorum to be reached, the vote to be successful, and the deadline to be reached.\\n *\\n * Emits a {ProposalQueued} event.\\n */\\n function queue(\\n address[] memory targets,\\n uint256[] memory values,\\n bytes[] memory calldatas,\\n bytes32 descriptionHash\\n ) external returns (uint256 proposalId);\\n\\n /**\\n * @dev Execute a successful proposal. This requires the quorum to be reached, the vote to be successful, and the\\n * deadline to be reached. Depending on the governor it might also be required that the proposal was queued and\\n * that some delay passed.\\n *\\n * Emits a {ProposalExecuted} event.\\n *\\n * NOTE: Some modules can modify the requirements for execution, for example by adding an additional timelock.\\n */\\n function execute(\\n address[] memory targets,\\n uint256[] memory values,\\n bytes[] memory calldatas,\\n bytes32 descriptionHash\\n ) external payable returns (uint256 proposalId);\\n\\n /**\\n * @dev Cancel a proposal. A proposal is cancellable by the proposer, but only while it is Pending state, i.e.\\n * before the vote starts.\\n *\\n * Emits a {ProposalCanceled} event.\\n */\\n function cancel(\\n address[] memory targets,\\n uint256[] memory values,\\n bytes[] memory calldatas,\\n bytes32 descriptionHash\\n ) external returns (uint256 proposalId);\\n\\n /**\\n * @dev Cast a vote\\n *\\n * Emits a {VoteCast} event.\\n */\\n function castVote(uint256 proposalId, uint8 support) external returns (uint256 balance);\\n\\n /**\\n * @dev Cast a vote with a reason\\n *\\n * Emits a {VoteCast} event.\\n */\\n function castVoteWithReason(\\n uint256 proposalId,\\n uint8 support,\\n string calldata reason\\n ) external returns (uint256 balance);\\n\\n /**\\n * @dev Cast a vote with a reason and additional encoded parameters\\n *\\n * Emits a {VoteCast} or {VoteCastWithParams} event depending on the length of params.\\n */\\n function castVoteWithReasonAndParams(\\n uint256 proposalId,\\n uint8 support,\\n string calldata reason,\\n bytes memory params\\n ) external returns (uint256 balance);\\n\\n /**\\n * @dev Cast a vote using the voter's signature, including ERC-1271 signature support.\\n *\\n * Emits a {VoteCast} event.\\n */\\n function castVoteBySig(\\n uint256 proposalId,\\n uint8 support,\\n address voter,\\n bytes memory signature\\n ) external returns (uint256 balance);\\n\\n /**\\n * @dev Cast a vote with a reason and additional encoded parameters using the voter's signature,\\n * including ERC-1271 signature support.\\n *\\n * Emits a {VoteCast} or {VoteCastWithParams} event depending on the length of params.\\n */\\n function castVoteWithReasonAndParamsBySig(\\n uint256 proposalId,\\n uint8 support,\\n address voter,\\n string calldata reason,\\n bytes memory params,\\n bytes memory signature\\n ) external returns (uint256 balance);\\n}\\n\",\"keccak256\":\"0x0a6c99ff573c20b62b8c568282517664e6d55000d4302aad10c668c97c0d2e0e\",\"license\":\"MIT\"},\"@openzeppelin/contracts/governance/utils/IVotes.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (governance/utils/IVotes.sol)\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Common interface for {ERC20Votes}, {ERC721Votes}, and other {Votes}-enabled contracts.\\n */\\ninterface IVotes {\\n /**\\n * @dev The signature used has expired.\\n */\\n error VotesExpiredSignature(uint256 expiry);\\n\\n /**\\n * @dev Emitted when an account changes their delegate.\\n */\\n event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);\\n\\n /**\\n * @dev Emitted when a token transfer or delegate change results in changes to a delegate's number of voting units.\\n */\\n event DelegateVotesChanged(address indexed delegate, uint256 previousVotes, uint256 newVotes);\\n\\n /**\\n * @dev Returns the current amount of votes that `account` has.\\n */\\n function getVotes(address account) external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of votes that `account` had at a specific moment in the past. If the `clock()` is\\n * configured to use block numbers, this will return the value at the end of the corresponding block.\\n */\\n function getPastVotes(address account, uint256 timepoint) external view returns (uint256);\\n\\n /**\\n * @dev Returns the total supply of votes available at a specific moment in the past. If the `clock()` is\\n * configured to use block numbers, this will return the value at the end of the corresponding block.\\n *\\n * NOTE: This value is the sum of all available votes, which is not necessarily the sum of all delegated votes.\\n * Votes that have not been delegated are still part of total supply, even though they would not participate in a\\n * vote.\\n */\\n function getPastTotalSupply(uint256 timepoint) external view returns (uint256);\\n\\n /**\\n * @dev Returns the delegate that `account` has chosen.\\n */\\n function delegates(address account) external view returns (address);\\n\\n /**\\n * @dev Delegates votes from the sender to `delegatee`.\\n */\\n function delegate(address delegatee) external;\\n\\n /**\\n * @dev Delegates votes from signer to `delegatee`.\\n */\\n function delegateBySig(address delegatee, uint256 nonce, uint256 expiry, uint8 v, bytes32 r, bytes32 s) external;\\n}\\n\",\"keccak256\":\"0x5e2b397ae88fd5c68e4f6762eb9f65f65c36702eb57796495f471d024ce70947\",\"license\":\"MIT\"},\"@openzeppelin/contracts/governance/utils/Votes.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (governance/utils/Votes.sol)\\npragma solidity ^0.8.20;\\n\\nimport {IERC5805} from \\\"../../interfaces/IERC5805.sol\\\";\\nimport {Context} from \\\"../../utils/Context.sol\\\";\\nimport {Nonces} from \\\"../../utils/Nonces.sol\\\";\\nimport {EIP712} from \\\"../../utils/cryptography/EIP712.sol\\\";\\nimport {Checkpoints} from \\\"../../utils/structs/Checkpoints.sol\\\";\\nimport {SafeCast} from \\\"../../utils/math/SafeCast.sol\\\";\\nimport {ECDSA} from \\\"../../utils/cryptography/ECDSA.sol\\\";\\nimport {Time} from \\\"../../utils/types/Time.sol\\\";\\n\\n/**\\n * @dev This is a base abstract contract that tracks voting units, which are a measure of voting power that can be\\n * transferred, and provides a system of vote delegation, where an account can delegate its voting units to a sort of\\n * \\\"representative\\\" that will pool delegated voting units from different accounts and can then use it to vote in\\n * decisions. In fact, voting units _must_ be delegated in order to count as actual votes, and an account has to\\n * delegate those votes to itself if it wishes to participate in decisions and does not have a trusted representative.\\n *\\n * This contract is often combined with a token contract such that voting units correspond to token units. For an\\n * example, see {ERC721Votes}.\\n *\\n * The full history of delegate votes is tracked on-chain so that governance protocols can consider votes as distributed\\n * at a particular block number to protect against flash loans and double voting. The opt-in delegate system makes the\\n * cost of this history tracking optional.\\n *\\n * When using this module the derived contract must implement {_getVotingUnits} (for example, make it return\\n * {ERC721-balanceOf}), and can use {_transferVotingUnits} to track a change in the distribution of those units (in the\\n * previous example, it would be included in {ERC721-_update}).\\n */\\nabstract contract Votes is Context, EIP712, Nonces, IERC5805 {\\n using Checkpoints for Checkpoints.Trace208;\\n\\n bytes32 private constant DELEGATION_TYPEHASH =\\n keccak256(\\\"Delegation(address delegatee,uint256 nonce,uint256 expiry)\\\");\\n\\n mapping(address account => address) private _delegatee;\\n\\n mapping(address delegatee => Checkpoints.Trace208) private _delegateCheckpoints;\\n\\n Checkpoints.Trace208 private _totalCheckpoints;\\n\\n /**\\n * @dev The clock was incorrectly modified.\\n */\\n error ERC6372InconsistentClock();\\n\\n /**\\n * @dev Lookup to future votes is not available.\\n */\\n error ERC5805FutureLookup(uint256 timepoint, uint48 clock);\\n\\n /**\\n * @dev Clock used for flagging checkpoints. Can be overridden to implement timestamp based\\n * checkpoints (and voting), in which case {CLOCK_MODE} should be overridden as well to match.\\n */\\n function clock() public view virtual returns (uint48) {\\n return Time.blockNumber();\\n }\\n\\n /**\\n * @dev Machine-readable description of the clock as specified in EIP-6372.\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function CLOCK_MODE() public view virtual returns (string memory) {\\n // Check that the clock was not modified\\n if (clock() != Time.blockNumber()) {\\n revert ERC6372InconsistentClock();\\n }\\n return \\\"mode=blocknumber&from=default\\\";\\n }\\n\\n /**\\n * @dev Returns the current amount of votes that `account` has.\\n */\\n function getVotes(address account) public view virtual returns (uint256) {\\n return _delegateCheckpoints[account].latest();\\n }\\n\\n /**\\n * @dev Returns the amount of votes that `account` had at a specific moment in the past. If the `clock()` is\\n * configured to use block numbers, this will return the value at the end of the corresponding block.\\n *\\n * Requirements:\\n *\\n * - `timepoint` must be in the past. If operating using block numbers, the block must be already mined.\\n */\\n function getPastVotes(address account, uint256 timepoint) public view virtual returns (uint256) {\\n uint48 currentTimepoint = clock();\\n if (timepoint >= currentTimepoint) {\\n revert ERC5805FutureLookup(timepoint, currentTimepoint);\\n }\\n return _delegateCheckpoints[account].upperLookupRecent(SafeCast.toUint48(timepoint));\\n }\\n\\n /**\\n * @dev Returns the total supply of votes available at a specific moment in the past. If the `clock()` is\\n * configured to use block numbers, this will return the value at the end of the corresponding block.\\n *\\n * NOTE: This value is the sum of all available votes, which is not necessarily the sum of all delegated votes.\\n * Votes that have not been delegated are still part of total supply, even though they would not participate in a\\n * vote.\\n *\\n * Requirements:\\n *\\n * - `timepoint` must be in the past. If operating using block numbers, the block must be already mined.\\n */\\n function getPastTotalSupply(uint256 timepoint) public view virtual returns (uint256) {\\n uint48 currentTimepoint = clock();\\n if (timepoint >= currentTimepoint) {\\n revert ERC5805FutureLookup(timepoint, currentTimepoint);\\n }\\n return _totalCheckpoints.upperLookupRecent(SafeCast.toUint48(timepoint));\\n }\\n\\n /**\\n * @dev Returns the current total supply of votes.\\n */\\n function _getTotalSupply() internal view virtual returns (uint256) {\\n return _totalCheckpoints.latest();\\n }\\n\\n /**\\n * @dev Returns the delegate that `account` has chosen.\\n */\\n function delegates(address account) public view virtual returns (address) {\\n return _delegatee[account];\\n }\\n\\n /**\\n * @dev Delegates votes from the sender to `delegatee`.\\n */\\n function delegate(address delegatee) public virtual {\\n address account = _msgSender();\\n _delegate(account, delegatee);\\n }\\n\\n /**\\n * @dev Delegates votes from signer to `delegatee`.\\n */\\n function delegateBySig(\\n address delegatee,\\n uint256 nonce,\\n uint256 expiry,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) public virtual {\\n if (block.timestamp > expiry) {\\n revert VotesExpiredSignature(expiry);\\n }\\n address signer = ECDSA.recover(\\n _hashTypedDataV4(keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry))),\\n v,\\n r,\\n s\\n );\\n _useCheckedNonce(signer, nonce);\\n _delegate(signer, delegatee);\\n }\\n\\n /**\\n * @dev Delegate all of `account`'s voting units to `delegatee`.\\n *\\n * Emits events {IVotes-DelegateChanged} and {IVotes-DelegateVotesChanged}.\\n */\\n function _delegate(address account, address delegatee) internal virtual {\\n address oldDelegate = delegates(account);\\n _delegatee[account] = delegatee;\\n\\n emit DelegateChanged(account, oldDelegate, delegatee);\\n _moveDelegateVotes(oldDelegate, delegatee, _getVotingUnits(account));\\n }\\n\\n /**\\n * @dev Transfers, mints, or burns voting units. To register a mint, `from` should be zero. To register a burn, `to`\\n * should be zero. Total supply of voting units will be adjusted with mints and burns.\\n */\\n function _transferVotingUnits(address from, address to, uint256 amount) internal virtual {\\n if (from == address(0)) {\\n _push(_totalCheckpoints, _add, SafeCast.toUint208(amount));\\n }\\n if (to == address(0)) {\\n _push(_totalCheckpoints, _subtract, SafeCast.toUint208(amount));\\n }\\n _moveDelegateVotes(delegates(from), delegates(to), amount);\\n }\\n\\n /**\\n * @dev Moves delegated votes from one delegate to another.\\n */\\n function _moveDelegateVotes(address from, address to, uint256 amount) private {\\n if (from != to && amount > 0) {\\n if (from != address(0)) {\\n (uint256 oldValue, uint256 newValue) = _push(\\n _delegateCheckpoints[from],\\n _subtract,\\n SafeCast.toUint208(amount)\\n );\\n emit DelegateVotesChanged(from, oldValue, newValue);\\n }\\n if (to != address(0)) {\\n (uint256 oldValue, uint256 newValue) = _push(\\n _delegateCheckpoints[to],\\n _add,\\n SafeCast.toUint208(amount)\\n );\\n emit DelegateVotesChanged(to, oldValue, newValue);\\n }\\n }\\n }\\n\\n /**\\n * @dev Get number of checkpoints for `account`.\\n */\\n function _numCheckpoints(address account) internal view virtual returns (uint32) {\\n return SafeCast.toUint32(_delegateCheckpoints[account].length());\\n }\\n\\n /**\\n * @dev Get the `pos`-th checkpoint for `account`.\\n */\\n function _checkpoints(\\n address account,\\n uint32 pos\\n ) internal view virtual returns (Checkpoints.Checkpoint208 memory) {\\n return _delegateCheckpoints[account].at(pos);\\n }\\n\\n function _push(\\n Checkpoints.Trace208 storage store,\\n function(uint208, uint208) view returns (uint208) op,\\n uint208 delta\\n ) private returns (uint208, uint208) {\\n return store.push(clock(), op(store.latest(), delta));\\n }\\n\\n function _add(uint208 a, uint208 b) private pure returns (uint208) {\\n return a + b;\\n }\\n\\n function _subtract(uint208 a, uint208 b) private pure returns (uint208) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Must return the voting units held by an account.\\n */\\n function _getVotingUnits(address) internal view virtual returns (uint256);\\n}\\n\",\"keccak256\":\"0xb8f69828d41b3594afd7a8c6393565901c205d8b5baf5bd2e42dbac637172979\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/IERC1271.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC1271.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Interface of the ERC1271 standard signature validation method for\\n * contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271].\\n */\\ninterface IERC1271 {\\n /**\\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 */\\n function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);\\n}\\n\",\"keccak256\":\"0x85a45f3f10014a0f8be41157a32b6a5f905753ea64a4b64e29fc12b7deeecf39\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0xde7e9fd9aee8d4f40772f96bb3b58836cbc6dfc0227014a061947f8821ea9724\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/IERC5267.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC5267.sol)\\n\\npragma solidity ^0.8.20;\\n\\ninterface IERC5267 {\\n /**\\n * @dev MAY be emitted to signal that the domain could have changed.\\n */\\n event EIP712DomainChanged();\\n\\n /**\\n * @dev returns the fields and values that describe the domain separator used by this contract for EIP-712\\n * signature.\\n */\\n function eip712Domain()\\n external\\n view\\n returns (\\n bytes1 fields,\\n string memory name,\\n string memory version,\\n uint256 chainId,\\n address verifyingContract,\\n bytes32 salt,\\n uint256[] memory extensions\\n );\\n}\\n\",\"keccak256\":\"0x92aa1df62dc3d33f1656d63bede0923e0df0b706ad4137c8b10b0a8fe549fd92\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/IERC5805.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC5805.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IVotes} from \\\"../governance/utils/IVotes.sol\\\";\\nimport {IERC6372} from \\\"./IERC6372.sol\\\";\\n\\ninterface IERC5805 is IERC6372, IVotes {}\\n\",\"keccak256\":\"0x4b9b89f91adbb7d3574f85394754cfb08c5b4eafca8a7061e2094a019ab8f818\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/IERC6372.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC6372.sol)\\n\\npragma solidity ^0.8.20;\\n\\ninterface IERC6372 {\\n /**\\n * @dev Clock used for flagging checkpoints. Can be overridden to implement timestamp based checkpoints (and voting).\\n */\\n function clock() external view returns (uint48);\\n\\n /**\\n * @dev Description of the clock\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function CLOCK_MODE() external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xeb2857b7dafb7e0d8526dbfe794e6c047df2851c9e6ee91dc4a55f3c34af5d33\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/draft-IERC1822.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC1822.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified\\n * proxy whose upgrades are fully controlled by the current implementation.\\n */\\ninterface IERC1822Proxiable {\\n /**\\n * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation\\n * address.\\n *\\n * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks\\n * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this\\n * function revert if invoked through a proxy.\\n */\\n function proxiableUUID() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0x2a1f9944df2015c081d89cd41ba22ffaf10aa6285969f0dc612b235cc448999c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/draft-IERC6093.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Standard ERC20 Errors\\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.\\n */\\ninterface IERC20Errors {\\n /**\\n * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\\n * @param sender Address whose tokens are being transferred.\\n * @param balance Current balance for the interacting account.\\n * @param needed Minimum amount required to perform a transfer.\\n */\\n error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);\\n\\n /**\\n * @dev Indicates a failure with the token `sender`. Used in transfers.\\n * @param sender Address whose tokens are being transferred.\\n */\\n error ERC20InvalidSender(address sender);\\n\\n /**\\n * @dev Indicates a failure with the token `receiver`. Used in transfers.\\n * @param receiver Address to which tokens are being transferred.\\n */\\n error ERC20InvalidReceiver(address receiver);\\n\\n /**\\n * @dev Indicates a failure with the `spender`\\u2019s `allowance`. Used in transfers.\\n * @param spender Address that may be allowed to operate on tokens without being their owner.\\n * @param allowance Amount of tokens a `spender` is allowed to operate with.\\n * @param needed Minimum amount required to perform a transfer.\\n */\\n error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);\\n\\n /**\\n * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\\n * @param approver Address initiating an approval operation.\\n */\\n error ERC20InvalidApprover(address approver);\\n\\n /**\\n * @dev Indicates a failure with the `spender` to be approved. Used in approvals.\\n * @param spender Address that may be allowed to operate on tokens without being their owner.\\n */\\n error ERC20InvalidSpender(address spender);\\n}\\n\\n/**\\n * @dev Standard ERC721 Errors\\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.\\n */\\ninterface IERC721Errors {\\n /**\\n * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.\\n * Used in balance queries.\\n * @param owner Address of the current owner of a token.\\n */\\n error ERC721InvalidOwner(address owner);\\n\\n /**\\n * @dev Indicates a `tokenId` whose `owner` is the zero address.\\n * @param tokenId Identifier number of a token.\\n */\\n error ERC721NonexistentToken(uint256 tokenId);\\n\\n /**\\n * @dev Indicates an error related to the ownership over a particular token. Used in transfers.\\n * @param sender Address whose tokens are being transferred.\\n * @param tokenId Identifier number of a token.\\n * @param owner Address of the current owner of a token.\\n */\\n error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);\\n\\n /**\\n * @dev Indicates a failure with the token `sender`. Used in transfers.\\n * @param sender Address whose tokens are being transferred.\\n */\\n error ERC721InvalidSender(address sender);\\n\\n /**\\n * @dev Indicates a failure with the token `receiver`. Used in transfers.\\n * @param receiver Address to which tokens are being transferred.\\n */\\n error ERC721InvalidReceiver(address receiver);\\n\\n /**\\n * @dev Indicates a failure with the `operator`\\u2019s approval. Used in transfers.\\n * @param operator Address that may be allowed to operate on tokens without being their owner.\\n * @param tokenId Identifier number of a token.\\n */\\n error ERC721InsufficientApproval(address operator, uint256 tokenId);\\n\\n /**\\n * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\\n * @param approver Address initiating an approval operation.\\n */\\n error ERC721InvalidApprover(address approver);\\n\\n /**\\n * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\\n * @param operator Address that may be allowed to operate on tokens without being their owner.\\n */\\n error ERC721InvalidOperator(address operator);\\n}\\n\\n/**\\n * @dev Standard ERC1155 Errors\\n * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.\\n */\\ninterface IERC1155Errors {\\n /**\\n * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.\\n * @param sender Address whose tokens are being transferred.\\n * @param balance Current balance for the interacting account.\\n * @param needed Minimum amount required to perform a transfer.\\n * @param tokenId Identifier number of a token.\\n */\\n error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);\\n\\n /**\\n * @dev Indicates a failure with the token `sender`. Used in transfers.\\n * @param sender Address whose tokens are being transferred.\\n */\\n error ERC1155InvalidSender(address sender);\\n\\n /**\\n * @dev Indicates a failure with the token `receiver`. Used in transfers.\\n * @param receiver Address to which tokens are being transferred.\\n */\\n error ERC1155InvalidReceiver(address receiver);\\n\\n /**\\n * @dev Indicates a failure with the `operator`\\u2019s approval. Used in transfers.\\n * @param operator Address that may be allowed to operate on tokens without being their owner.\\n * @param owner Address of the current owner of a token.\\n */\\n error ERC1155MissingApprovalForAll(address operator, address owner);\\n\\n /**\\n * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.\\n * @param approver Address initiating an approval operation.\\n */\\n error ERC1155InvalidApprover(address approver);\\n\\n /**\\n * @dev Indicates a failure with the `operator` to be approved. Used in approvals.\\n * @param operator Address that may be allowed to operate on tokens without being their owner.\\n */\\n error ERC1155InvalidOperator(address operator);\\n\\n /**\\n * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.\\n * Used in batch transfers.\\n * @param idsLength Length of the array of token identifiers\\n * @param valuesLength Length of the array of token amounts\\n */\\n error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);\\n}\\n\",\"keccak256\":\"0x60c65f701957fdd6faea1acb0bb45825791d473693ed9ecb34726fdfaa849dd7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (proxy/ERC1967/ERC1967Utils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IBeacon} from \\\"../beacon/IBeacon.sol\\\";\\nimport {Address} from \\\"../../utils/Address.sol\\\";\\nimport {StorageSlot} from \\\"../../utils/StorageSlot.sol\\\";\\n\\n/**\\n * @dev This abstract contract provides getters and event emitting update functions for\\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\\n */\\nlibrary ERC1967Utils {\\n // We re-declare ERC-1967 events here because they can't be used directly from IERC1967.\\n // This will be fixed in Solidity 0.8.21. At that point we should remove these events.\\n /**\\n * @dev Emitted when the implementation is upgraded.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Emitted when the admin account has changed.\\n */\\n event AdminChanged(address previousAdmin, address newAdmin);\\n\\n /**\\n * @dev Emitted when the beacon is changed.\\n */\\n event BeaconUpgraded(address indexed beacon);\\n\\n /**\\n * @dev Storage slot with the address of the current implementation.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.implementation\\\" subtracted by 1.\\n */\\n // solhint-disable-next-line private-vars-leading-underscore\\n bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n /**\\n * @dev The `implementation` of the proxy is invalid.\\n */\\n error ERC1967InvalidImplementation(address implementation);\\n\\n /**\\n * @dev The `admin` of the proxy is invalid.\\n */\\n error ERC1967InvalidAdmin(address admin);\\n\\n /**\\n * @dev The `beacon` of the proxy is invalid.\\n */\\n error ERC1967InvalidBeacon(address beacon);\\n\\n /**\\n * @dev An upgrade function sees `msg.value > 0` that may be lost.\\n */\\n error ERC1967NonPayable();\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function getImplementation() internal view returns (address) {\\n return StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 implementation slot.\\n */\\n function _setImplementation(address newImplementation) private {\\n if (newImplementation.code.length == 0) {\\n revert ERC1967InvalidImplementation(newImplementation);\\n }\\n StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value = newImplementation;\\n }\\n\\n /**\\n * @dev Performs implementation upgrade with additional setup call if data is nonempty.\\n * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected\\n * to avoid stuck value in the contract.\\n *\\n * Emits an {IERC1967-Upgraded} event.\\n */\\n function upgradeToAndCall(address newImplementation, bytes memory data) internal {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(newImplementation, data);\\n } else {\\n _checkNonPayable();\\n }\\n }\\n\\n /**\\n * @dev Storage slot with the admin of the contract.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.admin\\\" subtracted by 1.\\n */\\n // solhint-disable-next-line private-vars-leading-underscore\\n bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\\n\\n /**\\n * @dev Returns the current admin.\\n *\\n * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using\\n * the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.\\n * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`\\n */\\n function getAdmin() internal view returns (address) {\\n return StorageSlot.getAddressSlot(ADMIN_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 admin slot.\\n */\\n function _setAdmin(address newAdmin) private {\\n if (newAdmin == address(0)) {\\n revert ERC1967InvalidAdmin(address(0));\\n }\\n StorageSlot.getAddressSlot(ADMIN_SLOT).value = newAdmin;\\n }\\n\\n /**\\n * @dev Changes the admin of the proxy.\\n *\\n * Emits an {IERC1967-AdminChanged} event.\\n */\\n function changeAdmin(address newAdmin) internal {\\n emit AdminChanged(getAdmin(), newAdmin);\\n _setAdmin(newAdmin);\\n }\\n\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.beacon\\\" subtracted by 1.\\n */\\n // solhint-disable-next-line private-vars-leading-underscore\\n bytes32 internal constant BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Returns the current beacon.\\n */\\n function getBeacon() internal view returns (address) {\\n return StorageSlot.getAddressSlot(BEACON_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new beacon in the EIP1967 beacon slot.\\n */\\n function _setBeacon(address newBeacon) private {\\n if (newBeacon.code.length == 0) {\\n revert ERC1967InvalidBeacon(newBeacon);\\n }\\n\\n StorageSlot.getAddressSlot(BEACON_SLOT).value = newBeacon;\\n\\n address beaconImplementation = IBeacon(newBeacon).implementation();\\n if (beaconImplementation.code.length == 0) {\\n revert ERC1967InvalidImplementation(beaconImplementation);\\n }\\n }\\n\\n /**\\n * @dev Change the beacon and trigger a setup call if data is nonempty.\\n * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected\\n * to avoid stuck value in the contract.\\n *\\n * Emits an {IERC1967-BeaconUpgraded} event.\\n *\\n * CAUTION: Invoking this function has no effect on an instance of {BeaconProxy} since v5, since\\n * it uses an immutable beacon without looking at the value of the ERC-1967 beacon slot for\\n * efficiency.\\n */\\n function upgradeBeaconToAndCall(address newBeacon, bytes memory data) internal {\\n _setBeacon(newBeacon);\\n emit BeaconUpgraded(newBeacon);\\n\\n if (data.length > 0) {\\n Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);\\n } else {\\n _checkNonPayable();\\n }\\n }\\n\\n /**\\n * @dev Reverts if `msg.value` is not zero. It can be used to avoid `msg.value` stuck in the contract\\n * if an upgrade doesn't perform an initialization call.\\n */\\n function _checkNonPayable() private {\\n if (msg.value > 0) {\\n revert ERC1967NonPayable();\\n }\\n }\\n}\\n\",\"keccak256\":\"0x06a78f9b3ee3e6d0eb4e4cd635ba49960bea34cac1db8c0a27c75f2319f1fd65\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (proxy/beacon/IBeacon.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {UpgradeableBeacon} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0xc59a78b07b44b2cf2e8ab4175fca91e8eca1eee2df7357b8d2a8833e5ea1f64c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/IERC1155Receiver.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC165} from \\\"../../utils/introspection/IERC165.sol\\\";\\n\\n/**\\n * @dev Interface that must be implemented by smart contracts in order to receive\\n * ERC-1155 token transfers.\\n */\\ninterface IERC1155Receiver is IERC165 {\\n /**\\n * @dev Handles the receipt of a single ERC1155 token type. This function is\\n * called at the end of a `safeTransferFrom` after the balance has been updated.\\n *\\n * NOTE: To accept the transfer, this must return\\n * `bytes4(keccak256(\\\"onERC1155Received(address,address,uint256,uint256,bytes)\\\"))`\\n * (i.e. 0xf23a6e61, or its own function selector).\\n *\\n * @param operator The address which initiated the transfer (i.e. msg.sender)\\n * @param from The address which previously owned the token\\n * @param id The ID of the token being transferred\\n * @param value The amount of tokens being transferred\\n * @param data Additional data with no specified format\\n * @return `bytes4(keccak256(\\\"onERC1155Received(address,address,uint256,uint256,bytes)\\\"))` if transfer is allowed\\n */\\n function onERC1155Received(\\n address operator,\\n address from,\\n uint256 id,\\n uint256 value,\\n bytes calldata data\\n ) external returns (bytes4);\\n\\n /**\\n * @dev Handles the receipt of a multiple ERC1155 token types. This function\\n * is called at the end of a `safeBatchTransferFrom` after the balances have\\n * been updated.\\n *\\n * NOTE: To accept the transfer(s), this must return\\n * `bytes4(keccak256(\\\"onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)\\\"))`\\n * (i.e. 0xbc197c81, or its own function selector).\\n *\\n * @param operator The address which initiated the batch transfer (i.e. msg.sender)\\n * @param from The address which previously owned the token\\n * @param ids An array containing ids of each token being transferred (order and length must match values array)\\n * @param values An array containing amounts of each token being transferred (order and length must match ids array)\\n * @param data Additional data with no specified format\\n * @return `bytes4(keccak256(\\\"onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)\\\"))` if transfer is allowed\\n */\\n function onERC1155BatchReceived(\\n address operator,\\n address from,\\n uint256[] calldata ids,\\n uint256[] calldata values,\\n bytes calldata data\\n ) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0xb69597a63b202e28401128bed6a6d259e8730191274471af7303eafb247881a3\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\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(address indexed owner, address indexed spender, uint256 value);\\n\\n /**\\n * @dev Returns the value of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the value of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address to, uint256 value) external 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) external view returns (uint256);\\n\\n /**\\n * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n * 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 value) external returns (bool);\\n\\n /**\\n * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n * allowance mechanism. `value` 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(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0xc6a8ff0ea489379b61faa647490411b80102578440ab9d84e9a957cc12164e70\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC20 standard.\\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\",\"keccak256\":\"0xaa761817f6cd7892fcf158b3c776b34551cde36f48ff9703d53898bc45a94ea2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)\\n\\npragma solidity ^0.8.20;\\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 *\\n * ==== Security Considerations\\n *\\n * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature\\n * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be\\n * considered as an intention to spend the allowance in any specific way. The second is that because permits have\\n * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should\\n * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be\\n * generally recommended is:\\n *\\n * ```solidity\\n * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {\\n * try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}\\n * doThing(..., value);\\n * }\\n *\\n * function doThing(..., uint256 value) public {\\n * token.safeTransferFrom(msg.sender, address(this), value);\\n * ...\\n * }\\n * ```\\n *\\n * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of\\n * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also\\n * {SafeERC20-safeTransferFrom}).\\n *\\n * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so\\n * contracts should have entry points that don't rely on permit.\\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 * CAUTION: See Security Considerations above.\\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\",\"keccak256\":\"0x6008dabfe393240d73d7dd7688033f72740d570aa422254d29a7dce8568f3aff\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC20Permit} from \\\"../extensions/IERC20Permit.sol\\\";\\nimport {Address} from \\\"../../../utils/Address.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n using Address for address;\\n\\n /**\\n * @dev An operation with an ERC20 token failed.\\n */\\n error SafeERC20FailedOperation(address token);\\n\\n /**\\n * @dev Indicates a failed `decreaseAllowance` request.\\n */\\n error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n /**\\n * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n }\\n\\n /**\\n * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n */\\n function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n }\\n\\n /**\\n * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful.\\n */\\n function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n uint256 oldAllowance = token.allowance(address(this), spender);\\n forceApprove(token, spender, oldAllowance + value);\\n }\\n\\n /**\\n * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n * value, non-reverting calls are assumed to be successful.\\n */\\n function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n unchecked {\\n uint256 currentAllowance = token.allowance(address(this), spender);\\n if (currentAllowance < requestedDecrease) {\\n revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n }\\n forceApprove(token, spender, currentAllowance - requestedDecrease);\\n }\\n }\\n\\n /**\\n * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n * to be set to zero before setting it to a non-zero value, such as USDT.\\n */\\n function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n if (!_callOptionalReturnBool(token, approvalCall)) {\\n _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n _callOptionalReturn(token, approvalCall);\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n */\\n function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that\\n // the target address contains contract code and also asserts for success in the low-level call.\\n\\n bytes memory returndata = address(token).functionCall(data);\\n if (returndata.length != 0 && !abi.decode(returndata, (bool))) {\\n revert SafeERC20FailedOperation(address(token));\\n }\\n }\\n\\n /**\\n * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n * on the return value: the return value is optional (but if data is returned, it must not be false).\\n * @param token The token targeted by the call.\\n * @param data The call data (encoded using abi.encode or one of its variants).\\n *\\n * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.\\n */\\n function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\\n // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false\\n // and not revert is the subcall reverts.\\n\\n (bool success, bytes memory returndata) = address(token).call(data);\\n return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;\\n }\\n}\\n\",\"keccak256\":\"0x37bb49513c49c87c4642a891b13b63571bc87013dde806617aa1efb54605f386\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721Receiver.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @title ERC721 token receiver interface\\n * @dev Interface for any contract that wants to support safeTransfers\\n * from ERC721 asset contracts.\\n */\\ninterface IERC721Receiver {\\n /**\\n * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\\n * by `operator` from `from`, this function is called.\\n *\\n * It must return its Solidity selector to confirm the token transfer.\\n * If any other value is returned or the interface is not implemented by the recipient, the transfer will be\\n * reverted.\\n *\\n * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.\\n */\\n function onERC721Received(\\n address operator,\\n address from,\\n uint256 tokenId,\\n bytes calldata data\\n ) external returns (bytes4);\\n}\\n\",\"keccak256\":\"0x7f7a26306c79a65fb8b3b6c757cd74660c532cd8a02e165488e30027dd34ca49\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev The ETH balance of the account is not enough to perform the operation.\\n */\\n error AddressInsufficientBalance(address account);\\n\\n /**\\n * @dev There's no code at `target` (it is not a contract).\\n */\\n error AddressEmptyCode(address target);\\n\\n /**\\n * @dev A call to an address target failed. The target may have reverted.\\n */\\n error FailedInnerCall();\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n if (address(this).balance < amount) {\\n revert AddressInsufficientBalance(address(this));\\n }\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n if (!success) {\\n revert FailedInnerCall();\\n }\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason or custom error, it is bubbled\\n * up by this function (like regular Solidity function calls). However, if\\n * the call reverted with no returned reason, this function reverts with a\\n * {FailedInnerCall} error.\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n if (address(this).balance < value) {\\n revert AddressInsufficientBalance(address(this));\\n }\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResultFromTarget(target, success, returndata);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResultFromTarget(target, success, returndata);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return verifyCallResultFromTarget(target, success, returndata);\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target\\n * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an\\n * unsuccessful call.\\n */\\n function verifyCallResultFromTarget(\\n address target,\\n bool success,\\n bytes memory returndata\\n ) internal view returns (bytes memory) {\\n if (!success) {\\n _revert(returndata);\\n } else {\\n // only check if target is a contract if the call was successful and the return data is empty\\n // otherwise we already know that it was a contract\\n if (returndata.length == 0 && target.code.length == 0) {\\n revert AddressEmptyCode(target);\\n }\\n return returndata;\\n }\\n }\\n\\n /**\\n * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the\\n * revert reason or with a default {FailedInnerCall} error.\\n */\\n function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {\\n if (!success) {\\n _revert(returndata);\\n } else {\\n return returndata;\\n }\\n }\\n\\n /**\\n * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.\\n */\\n function _revert(bytes memory returndata) private pure {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert FailedInnerCall();\\n }\\n }\\n}\\n\",\"keccak256\":\"0xaf28a975a78550e45f65e559a3ad6a5ad43b9b8a37366999abd1b7084eb70721\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\\n\\npragma solidity ^0.8.20;\\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 function _contextSuffixLength() internal view virtual returns (uint256) {\\n return 0;\\n }\\n}\\n\",\"keccak256\":\"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Nonces.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Nonces.sol)\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Provides tracking nonces for addresses. Nonces will only increment.\\n */\\nabstract contract Nonces {\\n /**\\n * @dev The nonce used for an `account` is not the expected current nonce.\\n */\\n error InvalidAccountNonce(address account, uint256 currentNonce);\\n\\n mapping(address account => uint256) private _nonces;\\n\\n /**\\n * @dev Returns the next unused nonce for an address.\\n */\\n function nonces(address owner) public view virtual returns (uint256) {\\n return _nonces[owner];\\n }\\n\\n /**\\n * @dev Consumes a nonce.\\n *\\n * Returns the current value and increments nonce.\\n */\\n function _useNonce(address owner) internal virtual returns (uint256) {\\n // For each account, the nonce has an initial value of 0, can only be incremented by one, and cannot be\\n // decremented or reset. This guarantees that the nonce never overflows.\\n unchecked {\\n // It is important to do x++ and not ++x here.\\n return _nonces[owner]++;\\n }\\n }\\n\\n /**\\n * @dev Same as {_useNonce} but checking that `nonce` is the next valid for `owner`.\\n */\\n function _useCheckedNonce(address owner, uint256 nonce) internal virtual {\\n uint256 current = _useNonce(owner);\\n if (nonce != current) {\\n revert InvalidAccountNonce(owner, current);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0082767004fca261c332e9ad100868327a863a88ef724e844857128845ab350f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/ShortStrings.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/ShortStrings.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {StorageSlot} from \\\"./StorageSlot.sol\\\";\\n\\n// | string | 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |\\n// | length | 0x BB |\\ntype ShortString is bytes32;\\n\\n/**\\n * @dev This library provides functions to convert short memory strings\\n * into a `ShortString` type that can be used as an immutable variable.\\n *\\n * Strings of arbitrary length can be optimized using this library if\\n * they are short enough (up to 31 bytes) by packing them with their\\n * length (1 byte) in a single EVM word (32 bytes). Additionally, a\\n * fallback mechanism can be used for every other case.\\n *\\n * Usage example:\\n *\\n * ```solidity\\n * contract Named {\\n * using ShortStrings for *;\\n *\\n * ShortString private immutable _name;\\n * string private _nameFallback;\\n *\\n * constructor(string memory contractName) {\\n * _name = contractName.toShortStringWithFallback(_nameFallback);\\n * }\\n *\\n * function name() external view returns (string memory) {\\n * return _name.toStringWithFallback(_nameFallback);\\n * }\\n * }\\n * ```\\n */\\nlibrary ShortStrings {\\n // Used as an identifier for strings longer than 31 bytes.\\n bytes32 private constant FALLBACK_SENTINEL = 0x00000000000000000000000000000000000000000000000000000000000000FF;\\n\\n error StringTooLong(string str);\\n error InvalidShortString();\\n\\n /**\\n * @dev Encode a string of at most 31 chars into a `ShortString`.\\n *\\n * This will trigger a `StringTooLong` error is the input string is too long.\\n */\\n function toShortString(string memory str) internal pure returns (ShortString) {\\n bytes memory bstr = bytes(str);\\n if (bstr.length > 31) {\\n revert StringTooLong(str);\\n }\\n return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length));\\n }\\n\\n /**\\n * @dev Decode a `ShortString` back to a \\\"normal\\\" string.\\n */\\n function toString(ShortString sstr) internal pure returns (string memory) {\\n uint256 len = byteLength(sstr);\\n // using `new string(len)` would work locally but is not memory safe.\\n string memory str = new string(32);\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(str, len)\\n mstore(add(str, 0x20), sstr)\\n }\\n return str;\\n }\\n\\n /**\\n * @dev Return the length of a `ShortString`.\\n */\\n function byteLength(ShortString sstr) internal pure returns (uint256) {\\n uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF;\\n if (result > 31) {\\n revert InvalidShortString();\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Encode a string into a `ShortString`, or write it to storage if it is too long.\\n */\\n function toShortStringWithFallback(string memory value, string storage store) internal returns (ShortString) {\\n if (bytes(value).length < 32) {\\n return toShortString(value);\\n } else {\\n StorageSlot.getStringSlot(store).value = value;\\n return ShortString.wrap(FALLBACK_SENTINEL);\\n }\\n }\\n\\n /**\\n * @dev Decode a string that was encoded to `ShortString` or written to storage using {setWithFallback}.\\n */\\n function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) {\\n if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {\\n return toString(value);\\n } else {\\n return store;\\n }\\n }\\n\\n /**\\n * @dev Return the length of a string that was encoded to `ShortString` or written to storage using\\n * {setWithFallback}.\\n *\\n * WARNING: This will return the \\\"byte length\\\" of the string. This may not reflect the actual length in terms of\\n * actual characters as the UTF-8 encoding of a single character can span over multiple bytes.\\n */\\n function byteLengthWithFallback(ShortString value, string storage store) internal view returns (uint256) {\\n if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {\\n return byteLength(value);\\n } else {\\n return bytes(store).length;\\n }\\n }\\n}\\n\",\"keccak256\":\"0x18a7171df639a934592915a520ecb97c5bbc9675a1105607aac8a94e72bf62c6\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/StorageSlot.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/StorageSlot.sol)\\n// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Library for reading and writing primitive types to specific storage slots.\\n *\\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\\n * This library helps with reading and writing to such slots without the need for inline assembly.\\n *\\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\\n *\\n * Example usage to set ERC1967 implementation slot:\\n * ```solidity\\n * contract ERC1967 {\\n * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n *\\n * function _getImplementation() internal view returns (address) {\\n * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n * }\\n *\\n * function _setImplementation(address newImplementation) internal {\\n * require(newImplementation.code.length > 0);\\n * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n * }\\n * }\\n * ```\\n */\\nlibrary StorageSlot {\\n struct AddressSlot {\\n address value;\\n }\\n\\n struct BooleanSlot {\\n bool value;\\n }\\n\\n struct Bytes32Slot {\\n bytes32 value;\\n }\\n\\n struct Uint256Slot {\\n uint256 value;\\n }\\n\\n struct StringSlot {\\n string value;\\n }\\n\\n struct BytesSlot {\\n bytes value;\\n }\\n\\n /**\\n * @dev Returns an `AddressSlot` with member `value` located at `slot`.\\n */\\n function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\\n */\\n function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\\n */\\n function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\\n */\\n function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `StringSlot` with member `value` located at `slot`.\\n */\\n function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `StringSlot` representation of the string storage pointer `store`.\\n */\\n function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := store.slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `BytesSlot` with member `value` located at `slot`.\\n */\\n function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.\\n */\\n function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n r.slot := store.slot\\n }\\n }\\n}\\n\",\"keccak256\":\"0x32ba59b4b7299237c8ba56319110989d7978a039faf754793064e967e5894418\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Strings.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Math} from \\\"./math/Math.sol\\\";\\nimport {SignedMath} from \\\"./math/SignedMath.sol\\\";\\n\\n/**\\n * @dev String operations.\\n */\\nlibrary Strings {\\n bytes16 private constant HEX_DIGITS = \\\"0123456789abcdef\\\";\\n uint8 private constant ADDRESS_LENGTH = 20;\\n\\n /**\\n * @dev The `value` string doesn't fit in the specified `length`.\\n */\\n error StringsInsufficientHexLength(uint256 value, uint256 length);\\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 unchecked {\\n uint256 length = Math.log10(value) + 1;\\n string memory buffer = new string(length);\\n uint256 ptr;\\n /// @solidity memory-safe-assembly\\n assembly {\\n ptr := add(buffer, add(32, length))\\n }\\n while (true) {\\n ptr--;\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))\\n }\\n value /= 10;\\n if (value == 0) break;\\n }\\n return buffer;\\n }\\n }\\n\\n /**\\n * @dev Converts a `int256` to its ASCII `string` decimal representation.\\n */\\n function toStringSigned(int256 value) internal pure returns (string memory) {\\n return string.concat(value < 0 ? \\\"-\\\" : \\\"\\\", toString(SignedMath.abs(value)));\\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 unchecked {\\n return toHexString(value, Math.log256(value) + 1);\\n }\\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) internal pure returns (string memory) {\\n uint256 localValue = value;\\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_DIGITS[localValue & 0xf];\\n localValue >>= 4;\\n }\\n if (localValue != 0) {\\n revert StringsInsufficientHexLength(value, length);\\n }\\n return string(buffer);\\n }\\n\\n /**\\n * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal\\n * representation.\\n */\\n function toHexString(address addr) internal pure returns (string memory) {\\n return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);\\n }\\n\\n /**\\n * @dev Returns true if the two strings are equal.\\n */\\n function equal(string memory a, string memory b) internal pure returns (bool) {\\n return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));\\n }\\n}\\n\",\"keccak256\":\"0x55f102ea785d8399c0e58d1108e2d289506dde18abc6db1b7f68c1f9f9bc5792\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/ECDSA.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/ECDSA.sol)\\n\\npragma solidity ^0.8.20;\\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 }\\n\\n /**\\n * @dev The signature derives the `address(0)`.\\n */\\n error ECDSAInvalidSignature();\\n\\n /**\\n * @dev The signature has an invalid length.\\n */\\n error ECDSAInvalidSignatureLength(uint256 length);\\n\\n /**\\n * @dev The signature has an S value that is in the upper half order.\\n */\\n error ECDSAInvalidSignatureS(bytes32 s);\\n\\n /**\\n * @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not\\n * return address(0) without also returning an error description. Errors are documented using an enum (error type)\\n * and a bytes32 providing additional information about the error.\\n *\\n * If no error is returned, then the address can be used for verification purposes.\\n *\\n * The `ecrecover` EVM precompile 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 {MessageHashUtils-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 function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError, bytes32) {\\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 /// @solidity memory-safe-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 {\\n return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));\\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 precompile 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 {MessageHashUtils-toEthSignedMessageHash} on it.\\n */\\n function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\\n (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);\\n _throwError(error, errorArg);\\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 function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError, bytes32) {\\n unchecked {\\n bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);\\n // We do not check for an overflow here since the shift operation results in 0 or 1.\\n uint8 v = uint8((uint256(vs) >> 255) + 27);\\n return tryRecover(hash, v, r, s);\\n }\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.\\n */\\n function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {\\n (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);\\n _throwError(error, errorArg);\\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 function tryRecover(\\n bytes32 hash,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) internal pure returns (address, RecoverError, bytes32) {\\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 \\u00f7 2 + 1, and for v in (302): v \\u2208 {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 (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\\n return (address(0), RecoverError.InvalidSignatureS, s);\\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, bytes32(0));\\n }\\n\\n return (signer, RecoverError.NoError, bytes32(0));\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n */\\n function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {\\n (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);\\n _throwError(error, errorArg);\\n return recovered;\\n }\\n\\n /**\\n * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.\\n */\\n function _throwError(RecoverError error, bytes32 errorArg) private pure {\\n if (error == RecoverError.NoError) {\\n return; // no error: do nothing\\n } else if (error == RecoverError.InvalidSignature) {\\n revert ECDSAInvalidSignature();\\n } else if (error == RecoverError.InvalidSignatureLength) {\\n revert ECDSAInvalidSignatureLength(uint256(errorArg));\\n } else if (error == RecoverError.InvalidSignatureS) {\\n revert ECDSAInvalidSignatureS(errorArg);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xeed0a08b0b091f528356cbc7245891a4c748682d4f6a18055e8e6ca77d12a6cf\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/EIP712.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/EIP712.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {MessageHashUtils} from \\\"./MessageHashUtils.sol\\\";\\nimport {ShortStrings, ShortString} from \\\"../ShortStrings.sol\\\";\\nimport {IERC5267} from \\\"../../interfaces/IERC5267.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 scheme specified in the EIP requires a domain separator and a hash of the typed structured data, whose\\n * encoding is very generic and therefore its implementation in Solidity is not feasible, thus this contract\\n * does not implement the encoding itself. Protocols need to implement the type-specific encoding they need in order to\\n * produce the hash of their typed data 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 * NOTE: In the upgradeable version of this contract, the cached values will correspond to the address, and the domain\\n * separator of the implementation contract. This will cause the {_domainSeparatorV4} function to always rebuild the\\n * separator from the immutable values, which is cheaper than accessing a cached version in cold storage.\\n *\\n * @custom:oz-upgrades-unsafe-allow state-variable-immutable\\n */\\nabstract contract EIP712 is IERC5267 {\\n using ShortStrings for *;\\n\\n bytes32 private constant TYPE_HASH =\\n keccak256(\\\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\\\");\\n\\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 _cachedDomainSeparator;\\n uint256 private immutable _cachedChainId;\\n address private immutable _cachedThis;\\n\\n bytes32 private immutable _hashedName;\\n bytes32 private immutable _hashedVersion;\\n\\n ShortString private immutable _name;\\n ShortString private immutable _version;\\n string private _nameFallback;\\n string private _versionFallback;\\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 _name = name.toShortStringWithFallback(_nameFallback);\\n _version = version.toShortStringWithFallback(_versionFallback);\\n _hashedName = keccak256(bytes(name));\\n _hashedVersion = keccak256(bytes(version));\\n\\n _cachedChainId = block.chainid;\\n _cachedDomainSeparator = _buildDomainSeparator();\\n _cachedThis = address(this);\\n }\\n\\n /**\\n * @dev Returns the domain separator for the current chain.\\n */\\n function _domainSeparatorV4() internal view returns (bytes32) {\\n if (address(this) == _cachedThis && block.chainid == _cachedChainId) {\\n return _cachedDomainSeparator;\\n } else {\\n return _buildDomainSeparator();\\n }\\n }\\n\\n function _buildDomainSeparator() private view returns (bytes32) {\\n return keccak256(abi.encode(TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));\\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) internal view virtual returns (bytes32) {\\n return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);\\n }\\n\\n /**\\n * @dev See {IERC-5267}.\\n */\\n function eip712Domain()\\n public\\n view\\n virtual\\n returns (\\n bytes1 fields,\\n string memory name,\\n string memory version,\\n uint256 chainId,\\n address verifyingContract,\\n bytes32 salt,\\n uint256[] memory extensions\\n )\\n {\\n return (\\n hex\\\"0f\\\", // 01111\\n _EIP712Name(),\\n _EIP712Version(),\\n block.chainid,\\n address(this),\\n bytes32(0),\\n new uint256[](0)\\n );\\n }\\n\\n /**\\n * @dev The name parameter for the EIP712 domain.\\n *\\n * NOTE: By default this function reads _name which is an immutable value.\\n * It only reads from storage if necessary (in case the value is too large to fit in a ShortString).\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function _EIP712Name() internal view returns (string memory) {\\n return _name.toStringWithFallback(_nameFallback);\\n }\\n\\n /**\\n * @dev The version parameter for the EIP712 domain.\\n *\\n * NOTE: By default this function reads _version which is an immutable value.\\n * It only reads from storage if necessary (in case the value is too large to fit in a ShortString).\\n */\\n // solhint-disable-next-line func-name-mixedcase\\n function _EIP712Version() internal view returns (string memory) {\\n return _version.toStringWithFallback(_versionFallback);\\n }\\n}\\n\",\"keccak256\":\"0x999f705a027ed6dc2d4e0df2cc4a509852c6bfd11de1c8161bf88832d0503fd0\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/MerkleProof.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev These functions deal with verification of Merkle Tree proofs.\\n *\\n * The tree and the proofs can be generated using our\\n * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].\\n * You will find a quickstart guide in the readme.\\n *\\n * WARNING: You should avoid using leaf values that are 64 bytes long prior to\\n * hashing, or use a hash function other than keccak256 for hashing leaves.\\n * This is because the concatenation of a sorted pair of internal nodes in\\n * the Merkle tree could be reinterpreted as a leaf value.\\n * OpenZeppelin's JavaScript library generates Merkle trees that are safe\\n * against this attack out of the box.\\n */\\nlibrary MerkleProof {\\n /**\\n *@dev The multiproof provided is not valid.\\n */\\n error MerkleProofInvalidMultiproof();\\n\\n /**\\n * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\\n * defined by `root`. For this, a `proof` must be provided, containing\\n * sibling hashes on the branch from the leaf to the root of the tree. Each\\n * pair of leaves and each pair of pre-images are assumed to be sorted.\\n */\\n function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\\n return processProof(proof, leaf) == root;\\n }\\n\\n /**\\n * @dev Calldata version of {verify}\\n */\\n function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\\n return processProofCalldata(proof, leaf) == root;\\n }\\n\\n /**\\n * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up\\n * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt\\n * hash matches the root of the tree. When processing the proof, the pairs\\n * of leafs & pre-images are assumed to be sorted.\\n */\\n function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {\\n bytes32 computedHash = leaf;\\n for (uint256 i = 0; i < proof.length; i++) {\\n computedHash = _hashPair(computedHash, proof[i]);\\n }\\n return computedHash;\\n }\\n\\n /**\\n * @dev Calldata version of {processProof}\\n */\\n function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {\\n bytes32 computedHash = leaf;\\n for (uint256 i = 0; i < proof.length; i++) {\\n computedHash = _hashPair(computedHash, proof[i]);\\n }\\n return computedHash;\\n }\\n\\n /**\\n * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a Merkle tree defined by\\n * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.\\n *\\n * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.\\n */\\n function multiProofVerify(\\n bytes32[] memory proof,\\n bool[] memory proofFlags,\\n bytes32 root,\\n bytes32[] memory leaves\\n ) internal pure returns (bool) {\\n return processMultiProof(proof, proofFlags, leaves) == root;\\n }\\n\\n /**\\n * @dev Calldata version of {multiProofVerify}\\n *\\n * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.\\n */\\n function multiProofVerifyCalldata(\\n bytes32[] calldata proof,\\n bool[] calldata proofFlags,\\n bytes32 root,\\n bytes32[] memory leaves\\n ) internal pure returns (bool) {\\n return processMultiProofCalldata(proof, proofFlags, leaves) == root;\\n }\\n\\n /**\\n * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction\\n * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another\\n * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false\\n * respectively.\\n *\\n * CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree\\n * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the\\n * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).\\n */\\n function processMultiProof(\\n bytes32[] memory proof,\\n bool[] memory proofFlags,\\n bytes32[] memory leaves\\n ) internal pure returns (bytes32 merkleRoot) {\\n // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by\\n // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the\\n // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of\\n // the Merkle tree.\\n uint256 leavesLen = leaves.length;\\n uint256 proofLen = proof.length;\\n uint256 totalHashes = proofFlags.length;\\n\\n // Check proof validity.\\n if (leavesLen + proofLen != totalHashes + 1) {\\n revert MerkleProofInvalidMultiproof();\\n }\\n\\n // The xxxPos values are \\\"pointers\\\" to the next value to consume in each array. All accesses are done using\\n // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's \\\"pop\\\".\\n bytes32[] memory hashes = new bytes32[](totalHashes);\\n uint256 leafPos = 0;\\n uint256 hashPos = 0;\\n uint256 proofPos = 0;\\n // At each step, we compute the next hash using two values:\\n // - a value from the \\\"main queue\\\". If not all leaves have been consumed, we get the next leaf, otherwise we\\n // get the next hash.\\n // - depending on the flag, either another value from the \\\"main queue\\\" (merging branches) or an element from the\\n // `proof` array.\\n for (uint256 i = 0; i < totalHashes; i++) {\\n bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];\\n bytes32 b = proofFlags[i]\\n ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])\\n : proof[proofPos++];\\n hashes[i] = _hashPair(a, b);\\n }\\n\\n if (totalHashes > 0) {\\n if (proofPos != proofLen) {\\n revert MerkleProofInvalidMultiproof();\\n }\\n unchecked {\\n return hashes[totalHashes - 1];\\n }\\n } else if (leavesLen > 0) {\\n return leaves[0];\\n } else {\\n return proof[0];\\n }\\n }\\n\\n /**\\n * @dev Calldata version of {processMultiProof}.\\n *\\n * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.\\n */\\n function processMultiProofCalldata(\\n bytes32[] calldata proof,\\n bool[] calldata proofFlags,\\n bytes32[] memory leaves\\n ) internal pure returns (bytes32 merkleRoot) {\\n // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by\\n // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the\\n // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of\\n // the Merkle tree.\\n uint256 leavesLen = leaves.length;\\n uint256 proofLen = proof.length;\\n uint256 totalHashes = proofFlags.length;\\n\\n // Check proof validity.\\n if (leavesLen + proofLen != totalHashes + 1) {\\n revert MerkleProofInvalidMultiproof();\\n }\\n\\n // The xxxPos values are \\\"pointers\\\" to the next value to consume in each array. All accesses are done using\\n // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's \\\"pop\\\".\\n bytes32[] memory hashes = new bytes32[](totalHashes);\\n uint256 leafPos = 0;\\n uint256 hashPos = 0;\\n uint256 proofPos = 0;\\n // At each step, we compute the next hash using two values:\\n // - a value from the \\\"main queue\\\". If not all leaves have been consumed, we get the next leaf, otherwise we\\n // get the next hash.\\n // - depending on the flag, either another value from the \\\"main queue\\\" (merging branches) or an element from the\\n // `proof` array.\\n for (uint256 i = 0; i < totalHashes; i++) {\\n bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];\\n bytes32 b = proofFlags[i]\\n ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])\\n : proof[proofPos++];\\n hashes[i] = _hashPair(a, b);\\n }\\n\\n if (totalHashes > 0) {\\n if (proofPos != proofLen) {\\n revert MerkleProofInvalidMultiproof();\\n }\\n unchecked {\\n return hashes[totalHashes - 1];\\n }\\n } else if (leavesLen > 0) {\\n return leaves[0];\\n } else {\\n return proof[0];\\n }\\n }\\n\\n /**\\n * @dev Sorts the pair (a, b) and hashes the result.\\n */\\n function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {\\n return a < b ? _efficientHash(a, b) : _efficientHash(b, a);\\n }\\n\\n /**\\n * @dev Implementation of keccak256(abi.encode(a, b)) that doesn't allocate or expand memory.\\n */\\n function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, a)\\n mstore(0x20, b)\\n value := keccak256(0x00, 0x40)\\n }\\n }\\n}\\n\",\"keccak256\":\"0x6400c4bee15052e043e5d10315135972529bd1c8012f43da494dc6b4f4661058\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/MessageHashUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Strings} from \\\"../Strings.sol\\\";\\n\\n/**\\n * @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing.\\n *\\n * The library provides methods for generating a hash of a message that conforms to the\\n * https://eips.ethereum.org/EIPS/eip-191[EIP 191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712]\\n * specifications.\\n */\\nlibrary MessageHashUtils {\\n /**\\n * @dev Returns the keccak256 digest of an EIP-191 signed data with version\\n * `0x45` (`personal_sign` messages).\\n *\\n * The digest is calculated by prefixing a bytes32 `messageHash` with\\n * `\\\"\\\\x19Ethereum Signed Message:\\\\n32\\\"` and hashing the result. It corresponds with the\\n * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.\\n *\\n * NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with\\n * keccak256, although any bytes32 value can be safely used because the final digest will\\n * be re-hashed.\\n *\\n * See {ECDSA-recover}.\\n */\\n function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n mstore(0x00, \\\"\\\\x19Ethereum Signed Message:\\\\n32\\\") // 32 is the bytes-length of messageHash\\n mstore(0x1c, messageHash) // 0x1c (28) is the length of the prefix\\n digest := keccak256(0x00, 0x3c) // 0x3c is the length of the prefix (0x1c) + messageHash (0x20)\\n }\\n }\\n\\n /**\\n * @dev Returns the keccak256 digest of an EIP-191 signed data with version\\n * `0x45` (`personal_sign` messages).\\n *\\n * The digest is calculated by prefixing an arbitrary `message` with\\n * `\\\"\\\\x19Ethereum Signed Message:\\\\n\\\" + len(message)` and hashing the result. It corresponds with the\\n * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.\\n *\\n * See {ECDSA-recover}.\\n */\\n function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {\\n return\\n keccak256(bytes.concat(\\\"\\\\x19Ethereum Signed Message:\\\\n\\\", bytes(Strings.toString(message.length)), message));\\n }\\n\\n /**\\n * @dev Returns the keccak256 digest of an EIP-191 signed data with version\\n * `0x00` (data with intended validator).\\n *\\n * The digest is calculated by prefixing an arbitrary `data` with `\\\"\\\\x19\\\\x00\\\"` and the intended\\n * `validator` address. Then hashing the result.\\n *\\n * See {ECDSA-recover}.\\n */\\n function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {\\n return keccak256(abi.encodePacked(hex\\\"19_00\\\", validator, data));\\n }\\n\\n /**\\n * @dev Returns the keccak256 digest of an EIP-712 typed data (EIP-191 version `0x01`).\\n *\\n * The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with\\n * `\\\\x19\\\\x01` and hashing the result. It corresponds to the hash signed by the\\n * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712.\\n *\\n * See {ECDSA-recover}.\\n */\\n function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {\\n /// @solidity memory-safe-assembly\\n assembly {\\n let ptr := mload(0x40)\\n mstore(ptr, hex\\\"19_01\\\")\\n mstore(add(ptr, 0x02), domainSeparator)\\n mstore(add(ptr, 0x22), structHash)\\n digest := keccak256(ptr, 0x42)\\n }\\n }\\n}\\n\",\"keccak256\":\"0xba333517a3add42cd35fe877656fc3dfcc9de53baa4f3aabbd6d12a92e4ea435\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/SignatureChecker.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/SignatureChecker.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {ECDSA} from \\\"./ECDSA.sol\\\";\\nimport {IERC1271} from \\\"../../interfaces/IERC1271.sol\\\";\\n\\n/**\\n * @dev Signature verification helper that can be used instead of `ECDSA.recover` to seamlessly support both ECDSA\\n * signatures from externally owned accounts (EOAs) as well as ERC1271 signatures from smart contract wallets like\\n * Argent and Safe Wallet (previously Gnosis Safe).\\n */\\nlibrary SignatureChecker {\\n /**\\n * @dev Checks if a signature is valid for a given signer and data hash. If the signer is a smart contract, the\\n * signature is validated against that smart contract using ERC1271, otherwise it's validated using `ECDSA.recover`.\\n *\\n * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus\\n * change through time. It could return true at block N and false at block N+1 (or the opposite).\\n */\\n function isValidSignatureNow(address signer, bytes32 hash, bytes memory signature) internal view returns (bool) {\\n (address recovered, ECDSA.RecoverError error, ) = ECDSA.tryRecover(hash, signature);\\n return\\n (error == ECDSA.RecoverError.NoError && recovered == signer) ||\\n isValidERC1271SignatureNow(signer, hash, signature);\\n }\\n\\n /**\\n * @dev Checks if a signature is valid for a given signer and data hash. The signature is validated\\n * against the signer smart contract using ERC1271.\\n *\\n * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus\\n * change through time. It could return true at block N and false at block N+1 (or the opposite).\\n */\\n function isValidERC1271SignatureNow(\\n address signer,\\n bytes32 hash,\\n bytes memory signature\\n ) internal view returns (bool) {\\n (bool success, bytes memory result) = signer.staticcall(\\n abi.encodeCall(IERC1271.isValidSignature, (hash, signature))\\n );\\n return (success &&\\n result.length >= 32 &&\\n abi.decode(result, (bytes32)) == bytes32(IERC1271.isValidSignature.selector));\\n }\\n}\\n\",\"keccak256\":\"0x6b11eb41a228cca35d4b662b4df69fcd75192851365102690f57b2ac01e83fe6\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Interface of the ERC165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n /**\\n * @dev Returns true if this contract implements the interface defined by\\n * `interfaceId`. See the corresponding\\n * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\\n * to learn more about how these ids are created.\\n *\\n * This function call must use less than 30 000 gas.\\n */\\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x4296879f55019b23e135000eb36896057e7101fb7fb859c5ef690cf14643757b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n /**\\n * @dev Muldiv operation overflow.\\n */\\n error MathOverflowedMulDiv();\\n\\n enum Rounding {\\n Floor, // Toward negative infinity\\n Ceil, // Toward positive infinity\\n Trunc, // Toward zero\\n Expand // Away from zero\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, with an overflow flag.\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the largest of two numbers.\\n */\\n function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a > b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow.\\n return (a & b) + (a ^ b) / 2;\\n }\\n\\n /**\\n * @dev Returns the ceiling of the division of two numbers.\\n *\\n * This differs from standard division with `/` in that it rounds towards infinity instead\\n * of rounding towards zero.\\n */\\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n if (b == 0) {\\n // Guarantee the same behavior as in a regular Solidity division.\\n return a / b;\\n }\\n\\n // (a + b - 1) / b can overflow on addition, so we distribute.\\n return a == 0 ? 0 : (a - 1) / b + 1;\\n }\\n\\n /**\\n * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n * denominator == 0.\\n * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n * Uniswap Labs also under MIT license.\\n */\\n function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n unchecked {\\n // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\\n // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n // variables such that product = prod1 * 2^256 + prod0.\\n uint256 prod0 = x * y; // Least significant 256 bits of the product\\n uint256 prod1; // Most significant 256 bits of the product\\n assembly {\\n let mm := mulmod(x, y, not(0))\\n prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n }\\n\\n // Handle non-overflow cases, 256 by 256 division.\\n if (prod1 == 0) {\\n // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n // The surrounding unchecked block does not change this fact.\\n // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n return prod0 / denominator;\\n }\\n\\n // Make sure the result is less than 2^256. Also prevents denominator == 0.\\n if (denominator <= prod1) {\\n revert MathOverflowedMulDiv();\\n }\\n\\n ///////////////////////////////////////////////\\n // 512 by 256 division.\\n ///////////////////////////////////////////////\\n\\n // Make division exact by subtracting the remainder from [prod1 prod0].\\n uint256 remainder;\\n assembly {\\n // Compute remainder using mulmod.\\n remainder := mulmod(x, y, denominator)\\n\\n // Subtract 256 bit number from 512 bit number.\\n prod1 := sub(prod1, gt(remainder, prod0))\\n prod0 := sub(prod0, remainder)\\n }\\n\\n // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n uint256 twos = denominator & (0 - denominator);\\n assembly {\\n // Divide denominator by twos.\\n denominator := div(denominator, twos)\\n\\n // Divide [prod1 prod0] by twos.\\n prod0 := div(prod0, twos)\\n\\n // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\\n twos := add(div(sub(0, twos), twos), 1)\\n }\\n\\n // Shift in bits from prod1 into prod0.\\n prod0 |= prod1 * twos;\\n\\n // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\\n // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\\n // four bits. That is, denominator * inv = 1 mod 2^4.\\n uint256 inverse = (3 * denominator) ^ 2;\\n\\n // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n // works in modular arithmetic, doubling the correct bits in each step.\\n inverse *= 2 - denominator * inverse; // inverse mod 2^8\\n inverse *= 2 - denominator * inverse; // inverse mod 2^16\\n inverse *= 2 - denominator * inverse; // inverse mod 2^32\\n inverse *= 2 - denominator * inverse; // inverse mod 2^64\\n inverse *= 2 - denominator * inverse; // inverse mod 2^128\\n inverse *= 2 - denominator * inverse; // inverse mod 2^256\\n\\n // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\\n // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\\n // is no longer required.\\n result = prod0 * inverse;\\n return result;\\n }\\n }\\n\\n /**\\n * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\\n */\\n function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n uint256 result = mulDiv(x, y, denominator);\\n if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {\\n result += 1;\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n * towards zero.\\n *\\n * Inspired by Henry S. Warren, Jr.'s \\\"Hacker's Delight\\\" (Chapter 11).\\n */\\n function sqrt(uint256 a) internal pure returns (uint256) {\\n if (a == 0) {\\n return 0;\\n }\\n\\n // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\\n //\\n // We know that the \\\"msb\\\" (most significant bit) of our target number `a` is a power of 2 such that we have\\n // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\\n //\\n // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\\n // \\u2192 `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\\n // \\u2192 `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\\n //\\n // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\\n uint256 result = 1 << (log2(a) >> 1);\\n\\n // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\\n // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\\n // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\\n // into the expected uint128 result.\\n unchecked {\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n result = (result + a / result) >> 1;\\n return min(result, a / result);\\n }\\n }\\n\\n /**\\n * @notice Calculates sqrt(a), following the selected rounding direction.\\n */\\n function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = sqrt(a);\\n return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 2 of a positive value rounded towards zero.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 128;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 64;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 32;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 16;\\n }\\n if (value >> 8 > 0) {\\n value >>= 8;\\n result += 8;\\n }\\n if (value >> 4 > 0) {\\n value >>= 4;\\n result += 4;\\n }\\n if (value >> 2 > 0) {\\n value >>= 2;\\n result += 2;\\n }\\n if (value >> 1 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log2(value);\\n return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 10 of a positive value rounded towards zero.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >= 10 ** 64) {\\n value /= 10 ** 64;\\n result += 64;\\n }\\n if (value >= 10 ** 32) {\\n value /= 10 ** 32;\\n result += 32;\\n }\\n if (value >= 10 ** 16) {\\n value /= 10 ** 16;\\n result += 16;\\n }\\n if (value >= 10 ** 8) {\\n value /= 10 ** 8;\\n result += 8;\\n }\\n if (value >= 10 ** 4) {\\n value /= 10 ** 4;\\n result += 4;\\n }\\n if (value >= 10 ** 2) {\\n value /= 10 ** 2;\\n result += 2;\\n }\\n if (value >= 10 ** 1) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log10(value);\\n return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Return the log in base 256 of a positive value rounded towards zero.\\n * Returns 0 if given 0.\\n *\\n * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n */\\n function log256(uint256 value) internal pure returns (uint256) {\\n uint256 result = 0;\\n unchecked {\\n if (value >> 128 > 0) {\\n value >>= 128;\\n result += 16;\\n }\\n if (value >> 64 > 0) {\\n value >>= 64;\\n result += 8;\\n }\\n if (value >> 32 > 0) {\\n value >>= 32;\\n result += 4;\\n }\\n if (value >> 16 > 0) {\\n value >>= 16;\\n result += 2;\\n }\\n if (value >> 8 > 0) {\\n result += 1;\\n }\\n }\\n return result;\\n }\\n\\n /**\\n * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n * Returns 0 if given 0.\\n */\\n function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n unchecked {\\n uint256 result = log256(value);\\n return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);\\n }\\n }\\n\\n /**\\n * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n */\\n function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n return uint8(rounding) % 2 == 1;\\n }\\n}\\n\",\"keccak256\":\"0x005ec64c6313f0555d59e278f9a7a5ab2db5bdc72a027f255a37c327af1ec02d\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n /**\\n * @dev Value doesn't fit in an uint of `bits` size.\\n */\\n error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n /**\\n * @dev An int value doesn't fit in an uint of `bits` size.\\n */\\n error SafeCastOverflowedIntToUint(int256 value);\\n\\n /**\\n * @dev Value doesn't fit in an int of `bits` size.\\n */\\n error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n /**\\n * @dev An uint value doesn't fit in an int of `bits` size.\\n */\\n error SafeCastOverflowedUintToInt(uint256 value);\\n\\n /**\\n * @dev Returns the downcasted uint248 from uint256, reverting on\\n * overflow (when the input is greater than largest uint248).\\n *\\n * Counterpart to Solidity's `uint248` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 248 bits\\n */\\n function toUint248(uint256 value) internal pure returns (uint248) {\\n if (value > type(uint248).max) {\\n revert SafeCastOverflowedUintDowncast(248, value);\\n }\\n return uint248(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint240 from uint256, reverting on\\n * overflow (when the input is greater than largest uint240).\\n *\\n * Counterpart to Solidity's `uint240` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 240 bits\\n */\\n function toUint240(uint256 value) internal pure returns (uint240) {\\n if (value > type(uint240).max) {\\n revert SafeCastOverflowedUintDowncast(240, value);\\n }\\n return uint240(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint232 from uint256, reverting on\\n * overflow (when the input is greater than largest uint232).\\n *\\n * Counterpart to Solidity's `uint232` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 232 bits\\n */\\n function toUint232(uint256 value) internal pure returns (uint232) {\\n if (value > type(uint232).max) {\\n revert SafeCastOverflowedUintDowncast(232, value);\\n }\\n return uint232(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint224 from uint256, reverting on\\n * overflow (when the input is greater than largest uint224).\\n *\\n * Counterpart to Solidity's `uint224` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 224 bits\\n */\\n function toUint224(uint256 value) internal pure returns (uint224) {\\n if (value > type(uint224).max) {\\n revert SafeCastOverflowedUintDowncast(224, value);\\n }\\n return uint224(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint216 from uint256, reverting on\\n * overflow (when the input is greater than largest uint216).\\n *\\n * Counterpart to Solidity's `uint216` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 216 bits\\n */\\n function toUint216(uint256 value) internal pure returns (uint216) {\\n if (value > type(uint216).max) {\\n revert SafeCastOverflowedUintDowncast(216, value);\\n }\\n return uint216(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint208 from uint256, reverting on\\n * overflow (when the input is greater than largest uint208).\\n *\\n * Counterpart to Solidity's `uint208` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 208 bits\\n */\\n function toUint208(uint256 value) internal pure returns (uint208) {\\n if (value > type(uint208).max) {\\n revert SafeCastOverflowedUintDowncast(208, value);\\n }\\n return uint208(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint200 from uint256, reverting on\\n * overflow (when the input is greater than largest uint200).\\n *\\n * Counterpart to Solidity's `uint200` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 200 bits\\n */\\n function toUint200(uint256 value) internal pure returns (uint200) {\\n if (value > type(uint200).max) {\\n revert SafeCastOverflowedUintDowncast(200, value);\\n }\\n return uint200(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint192 from uint256, reverting on\\n * overflow (when the input is greater than largest uint192).\\n *\\n * Counterpart to Solidity's `uint192` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 192 bits\\n */\\n function toUint192(uint256 value) internal pure returns (uint192) {\\n if (value > type(uint192).max) {\\n revert SafeCastOverflowedUintDowncast(192, value);\\n }\\n return uint192(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint184 from uint256, reverting on\\n * overflow (when the input is greater than largest uint184).\\n *\\n * Counterpart to Solidity's `uint184` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 184 bits\\n */\\n function toUint184(uint256 value) internal pure returns (uint184) {\\n if (value > type(uint184).max) {\\n revert SafeCastOverflowedUintDowncast(184, value);\\n }\\n return uint184(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint176 from uint256, reverting on\\n * overflow (when the input is greater than largest uint176).\\n *\\n * Counterpart to Solidity's `uint176` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 176 bits\\n */\\n function toUint176(uint256 value) internal pure returns (uint176) {\\n if (value > type(uint176).max) {\\n revert SafeCastOverflowedUintDowncast(176, value);\\n }\\n return uint176(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint168 from uint256, reverting on\\n * overflow (when the input is greater than largest uint168).\\n *\\n * Counterpart to Solidity's `uint168` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 168 bits\\n */\\n function toUint168(uint256 value) internal pure returns (uint168) {\\n if (value > type(uint168).max) {\\n revert SafeCastOverflowedUintDowncast(168, value);\\n }\\n return uint168(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint160 from uint256, reverting on\\n * overflow (when the input is greater than largest uint160).\\n *\\n * Counterpart to Solidity's `uint160` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 160 bits\\n */\\n function toUint160(uint256 value) internal pure returns (uint160) {\\n if (value > type(uint160).max) {\\n revert SafeCastOverflowedUintDowncast(160, value);\\n }\\n return uint160(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint152 from uint256, reverting on\\n * overflow (when the input is greater than largest uint152).\\n *\\n * Counterpart to Solidity's `uint152` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 152 bits\\n */\\n function toUint152(uint256 value) internal pure returns (uint152) {\\n if (value > type(uint152).max) {\\n revert SafeCastOverflowedUintDowncast(152, value);\\n }\\n return uint152(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint144 from uint256, reverting on\\n * overflow (when the input is greater than largest uint144).\\n *\\n * Counterpart to Solidity's `uint144` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 144 bits\\n */\\n function toUint144(uint256 value) internal pure returns (uint144) {\\n if (value > type(uint144).max) {\\n revert SafeCastOverflowedUintDowncast(144, value);\\n }\\n return uint144(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint136 from uint256, reverting on\\n * overflow (when the input is greater than largest uint136).\\n *\\n * Counterpart to Solidity's `uint136` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 136 bits\\n */\\n function toUint136(uint256 value) internal pure returns (uint136) {\\n if (value > type(uint136).max) {\\n revert SafeCastOverflowedUintDowncast(136, value);\\n }\\n return uint136(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint128 from uint256, reverting on\\n * overflow (when the input is greater than largest uint128).\\n *\\n * Counterpart to Solidity's `uint128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n */\\n function toUint128(uint256 value) internal pure returns (uint128) {\\n if (value > type(uint128).max) {\\n revert SafeCastOverflowedUintDowncast(128, value);\\n }\\n return uint128(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint120 from uint256, reverting on\\n * overflow (when the input is greater than largest uint120).\\n *\\n * Counterpart to Solidity's `uint120` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 120 bits\\n */\\n function toUint120(uint256 value) internal pure returns (uint120) {\\n if (value > type(uint120).max) {\\n revert SafeCastOverflowedUintDowncast(120, value);\\n }\\n return uint120(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint112 from uint256, reverting on\\n * overflow (when the input is greater than largest uint112).\\n *\\n * Counterpart to Solidity's `uint112` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 112 bits\\n */\\n function toUint112(uint256 value) internal pure returns (uint112) {\\n if (value > type(uint112).max) {\\n revert SafeCastOverflowedUintDowncast(112, value);\\n }\\n return uint112(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint104 from uint256, reverting on\\n * overflow (when the input is greater than largest uint104).\\n *\\n * Counterpart to Solidity's `uint104` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 104 bits\\n */\\n function toUint104(uint256 value) internal pure returns (uint104) {\\n if (value > type(uint104).max) {\\n revert SafeCastOverflowedUintDowncast(104, value);\\n }\\n return uint104(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint96 from uint256, reverting on\\n * overflow (when the input is greater than largest uint96).\\n *\\n * Counterpart to Solidity's `uint96` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 96 bits\\n */\\n function toUint96(uint256 value) internal pure returns (uint96) {\\n if (value > type(uint96).max) {\\n revert SafeCastOverflowedUintDowncast(96, value);\\n }\\n return uint96(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint88 from uint256, reverting on\\n * overflow (when the input is greater than largest uint88).\\n *\\n * Counterpart to Solidity's `uint88` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 88 bits\\n */\\n function toUint88(uint256 value) internal pure returns (uint88) {\\n if (value > type(uint88).max) {\\n revert SafeCastOverflowedUintDowncast(88, value);\\n }\\n return uint88(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint80 from uint256, reverting on\\n * overflow (when the input is greater than largest uint80).\\n *\\n * Counterpart to Solidity's `uint80` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 80 bits\\n */\\n function toUint80(uint256 value) internal pure returns (uint80) {\\n if (value > type(uint80).max) {\\n revert SafeCastOverflowedUintDowncast(80, value);\\n }\\n return uint80(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint72 from uint256, reverting on\\n * overflow (when the input is greater than largest uint72).\\n *\\n * Counterpart to Solidity's `uint72` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 72 bits\\n */\\n function toUint72(uint256 value) internal pure returns (uint72) {\\n if (value > type(uint72).max) {\\n revert SafeCastOverflowedUintDowncast(72, value);\\n }\\n return uint72(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint64 from uint256, reverting on\\n * overflow (when the input is greater than largest uint64).\\n *\\n * Counterpart to Solidity's `uint64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n */\\n function toUint64(uint256 value) internal pure returns (uint64) {\\n if (value > type(uint64).max) {\\n revert SafeCastOverflowedUintDowncast(64, value);\\n }\\n return uint64(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint56 from uint256, reverting on\\n * overflow (when the input is greater than largest uint56).\\n *\\n * Counterpart to Solidity's `uint56` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 56 bits\\n */\\n function toUint56(uint256 value) internal pure returns (uint56) {\\n if (value > type(uint56).max) {\\n revert SafeCastOverflowedUintDowncast(56, value);\\n }\\n return uint56(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint48 from uint256, reverting on\\n * overflow (when the input is greater than largest uint48).\\n *\\n * Counterpart to Solidity's `uint48` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 48 bits\\n */\\n function toUint48(uint256 value) internal pure returns (uint48) {\\n if (value > type(uint48).max) {\\n revert SafeCastOverflowedUintDowncast(48, value);\\n }\\n return uint48(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint40 from uint256, reverting on\\n * overflow (when the input is greater than largest uint40).\\n *\\n * Counterpart to Solidity's `uint40` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 40 bits\\n */\\n function toUint40(uint256 value) internal pure returns (uint40) {\\n if (value > type(uint40).max) {\\n revert SafeCastOverflowedUintDowncast(40, value);\\n }\\n return uint40(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint32 from uint256, reverting on\\n * overflow (when the input is greater than largest uint32).\\n *\\n * Counterpart to Solidity's `uint32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n */\\n function toUint32(uint256 value) internal pure returns (uint32) {\\n if (value > type(uint32).max) {\\n revert SafeCastOverflowedUintDowncast(32, value);\\n }\\n return uint32(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint24 from uint256, reverting on\\n * overflow (when the input is greater than largest uint24).\\n *\\n * Counterpart to Solidity's `uint24` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 24 bits\\n */\\n function toUint24(uint256 value) internal pure returns (uint24) {\\n if (value > type(uint24).max) {\\n revert SafeCastOverflowedUintDowncast(24, value);\\n }\\n return uint24(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint16 from uint256, reverting on\\n * overflow (when the input is greater than largest uint16).\\n *\\n * Counterpart to Solidity's `uint16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n */\\n function toUint16(uint256 value) internal pure returns (uint16) {\\n if (value > type(uint16).max) {\\n revert SafeCastOverflowedUintDowncast(16, value);\\n }\\n return uint16(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted uint8 from uint256, reverting on\\n * overflow (when the input is greater than largest uint8).\\n *\\n * Counterpart to Solidity's `uint8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits\\n */\\n function toUint8(uint256 value) internal pure returns (uint8) {\\n if (value > type(uint8).max) {\\n revert SafeCastOverflowedUintDowncast(8, value);\\n }\\n return uint8(value);\\n }\\n\\n /**\\n * @dev Converts a signed int256 into an unsigned uint256.\\n *\\n * Requirements:\\n *\\n * - input must be greater than or equal to 0.\\n */\\n function toUint256(int256 value) internal pure returns (uint256) {\\n if (value < 0) {\\n revert SafeCastOverflowedIntToUint(value);\\n }\\n return uint256(value);\\n }\\n\\n /**\\n * @dev Returns the downcasted int248 from int256, reverting on\\n * overflow (when the input is less than smallest int248 or\\n * greater than largest int248).\\n *\\n * Counterpart to Solidity's `int248` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 248 bits\\n */\\n function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n downcasted = int248(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(248, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int240 from int256, reverting on\\n * overflow (when the input is less than smallest int240 or\\n * greater than largest int240).\\n *\\n * Counterpart to Solidity's `int240` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 240 bits\\n */\\n function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n downcasted = int240(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(240, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int232 from int256, reverting on\\n * overflow (when the input is less than smallest int232 or\\n * greater than largest int232).\\n *\\n * Counterpart to Solidity's `int232` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 232 bits\\n */\\n function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n downcasted = int232(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(232, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int224 from int256, reverting on\\n * overflow (when the input is less than smallest int224 or\\n * greater than largest int224).\\n *\\n * Counterpart to Solidity's `int224` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 224 bits\\n */\\n function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n downcasted = int224(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(224, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int216 from int256, reverting on\\n * overflow (when the input is less than smallest int216 or\\n * greater than largest int216).\\n *\\n * Counterpart to Solidity's `int216` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 216 bits\\n */\\n function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n downcasted = int216(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(216, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int208 from int256, reverting on\\n * overflow (when the input is less than smallest int208 or\\n * greater than largest int208).\\n *\\n * Counterpart to Solidity's `int208` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 208 bits\\n */\\n function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n downcasted = int208(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(208, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int200 from int256, reverting on\\n * overflow (when the input is less than smallest int200 or\\n * greater than largest int200).\\n *\\n * Counterpart to Solidity's `int200` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 200 bits\\n */\\n function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n downcasted = int200(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(200, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int192 from int256, reverting on\\n * overflow (when the input is less than smallest int192 or\\n * greater than largest int192).\\n *\\n * Counterpart to Solidity's `int192` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 192 bits\\n */\\n function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n downcasted = int192(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(192, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int184 from int256, reverting on\\n * overflow (when the input is less than smallest int184 or\\n * greater than largest int184).\\n *\\n * Counterpart to Solidity's `int184` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 184 bits\\n */\\n function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n downcasted = int184(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(184, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int176 from int256, reverting on\\n * overflow (when the input is less than smallest int176 or\\n * greater than largest int176).\\n *\\n * Counterpart to Solidity's `int176` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 176 bits\\n */\\n function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n downcasted = int176(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(176, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int168 from int256, reverting on\\n * overflow (when the input is less than smallest int168 or\\n * greater than largest int168).\\n *\\n * Counterpart to Solidity's `int168` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 168 bits\\n */\\n function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n downcasted = int168(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(168, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int160 from int256, reverting on\\n * overflow (when the input is less than smallest int160 or\\n * greater than largest int160).\\n *\\n * Counterpart to Solidity's `int160` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 160 bits\\n */\\n function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n downcasted = int160(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(160, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int152 from int256, reverting on\\n * overflow (when the input is less than smallest int152 or\\n * greater than largest int152).\\n *\\n * Counterpart to Solidity's `int152` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 152 bits\\n */\\n function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n downcasted = int152(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(152, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int144 from int256, reverting on\\n * overflow (when the input is less than smallest int144 or\\n * greater than largest int144).\\n *\\n * Counterpart to Solidity's `int144` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 144 bits\\n */\\n function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n downcasted = int144(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(144, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int136 from int256, reverting on\\n * overflow (when the input is less than smallest int136 or\\n * greater than largest int136).\\n *\\n * Counterpart to Solidity's `int136` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 136 bits\\n */\\n function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n downcasted = int136(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(136, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int128 from int256, reverting on\\n * overflow (when the input is less than smallest int128 or\\n * greater than largest int128).\\n *\\n * Counterpart to Solidity's `int128` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 128 bits\\n */\\n function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n downcasted = int128(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(128, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int120 from int256, reverting on\\n * overflow (when the input is less than smallest int120 or\\n * greater than largest int120).\\n *\\n * Counterpart to Solidity's `int120` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 120 bits\\n */\\n function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n downcasted = int120(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(120, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int112 from int256, reverting on\\n * overflow (when the input is less than smallest int112 or\\n * greater than largest int112).\\n *\\n * Counterpart to Solidity's `int112` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 112 bits\\n */\\n function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n downcasted = int112(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(112, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int104 from int256, reverting on\\n * overflow (when the input is less than smallest int104 or\\n * greater than largest int104).\\n *\\n * Counterpart to Solidity's `int104` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 104 bits\\n */\\n function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n downcasted = int104(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(104, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int96 from int256, reverting on\\n * overflow (when the input is less than smallest int96 or\\n * greater than largest int96).\\n *\\n * Counterpart to Solidity's `int96` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 96 bits\\n */\\n function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n downcasted = int96(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(96, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int88 from int256, reverting on\\n * overflow (when the input is less than smallest int88 or\\n * greater than largest int88).\\n *\\n * Counterpart to Solidity's `int88` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 88 bits\\n */\\n function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n downcasted = int88(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(88, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int80 from int256, reverting on\\n * overflow (when the input is less than smallest int80 or\\n * greater than largest int80).\\n *\\n * Counterpart to Solidity's `int80` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 80 bits\\n */\\n function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n downcasted = int80(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(80, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int72 from int256, reverting on\\n * overflow (when the input is less than smallest int72 or\\n * greater than largest int72).\\n *\\n * Counterpart to Solidity's `int72` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 72 bits\\n */\\n function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n downcasted = int72(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(72, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int64 from int256, reverting on\\n * overflow (when the input is less than smallest int64 or\\n * greater than largest int64).\\n *\\n * Counterpart to Solidity's `int64` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 64 bits\\n */\\n function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n downcasted = int64(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(64, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int56 from int256, reverting on\\n * overflow (when the input is less than smallest int56 or\\n * greater than largest int56).\\n *\\n * Counterpart to Solidity's `int56` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 56 bits\\n */\\n function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n downcasted = int56(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(56, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int48 from int256, reverting on\\n * overflow (when the input is less than smallest int48 or\\n * greater than largest int48).\\n *\\n * Counterpart to Solidity's `int48` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 48 bits\\n */\\n function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n downcasted = int48(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(48, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int40 from int256, reverting on\\n * overflow (when the input is less than smallest int40 or\\n * greater than largest int40).\\n *\\n * Counterpart to Solidity's `int40` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 40 bits\\n */\\n function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n downcasted = int40(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(40, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int32 from int256, reverting on\\n * overflow (when the input is less than smallest int32 or\\n * greater than largest int32).\\n *\\n * Counterpart to Solidity's `int32` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 32 bits\\n */\\n function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n downcasted = int32(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(32, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int24 from int256, reverting on\\n * overflow (when the input is less than smallest int24 or\\n * greater than largest int24).\\n *\\n * Counterpart to Solidity's `int24` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 24 bits\\n */\\n function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n downcasted = int24(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(24, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int16 from int256, reverting on\\n * overflow (when the input is less than smallest int16 or\\n * greater than largest int16).\\n *\\n * Counterpart to Solidity's `int16` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 16 bits\\n */\\n function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n downcasted = int16(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(16, value);\\n }\\n }\\n\\n /**\\n * @dev Returns the downcasted int8 from int256, reverting on\\n * overflow (when the input is less than smallest int8 or\\n * greater than largest int8).\\n *\\n * Counterpart to Solidity's `int8` operator.\\n *\\n * Requirements:\\n *\\n * - input must fit into 8 bits\\n */\\n function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n downcasted = int8(value);\\n if (downcasted != value) {\\n revert SafeCastOverflowedIntDowncast(8, value);\\n }\\n }\\n\\n /**\\n * @dev Converts an unsigned uint256 into a signed int256.\\n *\\n * Requirements:\\n *\\n * - input must be less than or equal to maxInt256.\\n */\\n function toInt256(uint256 value) internal pure returns (int256) {\\n // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n if (value > uint256(type(int256).max)) {\\n revert SafeCastOverflowedUintToInt(value);\\n }\\n return int256(value);\\n }\\n}\\n\",\"keccak256\":\"0xe19a4d5f31d2861e7344e8e535e2feafb913d806d3e2b5fe7782741a2a7094fe\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SignedMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Standard signed math utilities missing in the Solidity language.\\n */\\nlibrary SignedMath {\\n /**\\n * @dev Returns the largest of two signed numbers.\\n */\\n function max(int256 a, int256 b) internal pure returns (int256) {\\n return a > b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two signed numbers.\\n */\\n function min(int256 a, int256 b) internal pure returns (int256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two signed numbers without overflow.\\n * The result is rounded towards zero.\\n */\\n function average(int256 a, int256 b) internal pure returns (int256) {\\n // Formula from the book \\\"Hacker's Delight\\\"\\n int256 x = (a & b) + ((a ^ b) >> 1);\\n return x + (int256(uint256(x) >> 255) & (a ^ b));\\n }\\n\\n /**\\n * @dev Returns the absolute unsigned value of a signed value.\\n */\\n function abs(int256 n) internal pure returns (uint256) {\\n unchecked {\\n // must be unchecked in order to support `n = type(int256).min`\\n return uint256(n >= 0 ? n : -n);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5f7e4076e175393767754387c962926577f1660dd9b810187b9002407656be72\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/Checkpoints.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/structs/Checkpoints.sol)\\n// This file was procedurally generated from scripts/generate/templates/Checkpoints.js.\\n\\npragma solidity ^0.8.20;\\n\\nimport {Math} from \\\"../math/Math.sol\\\";\\n\\n/**\\n * @dev This library defines the `Trace*` struct, for checkpointing values as they change at different points in\\n * time, and later looking up past values by block number. See {Votes} as an example.\\n *\\n * To create a history of checkpoints define a variable type `Checkpoints.Trace*` in your contract, and store a new\\n * checkpoint for the current transaction block using the {push} function.\\n */\\nlibrary Checkpoints {\\n /**\\n * @dev A value was attempted to be inserted on a past checkpoint.\\n */\\n error CheckpointUnorderedInsertion();\\n\\n struct Trace224 {\\n Checkpoint224[] _checkpoints;\\n }\\n\\n struct Checkpoint224 {\\n uint32 _key;\\n uint224 _value;\\n }\\n\\n /**\\n * @dev Pushes a (`key`, `value`) pair into a Trace224 so that it is stored as the checkpoint.\\n *\\n * Returns previous value and new value.\\n *\\n * IMPORTANT: Never accept `key` as a user input, since an arbitrary `type(uint32).max` key set will disable the\\n * library.\\n */\\n function push(Trace224 storage self, uint32 key, uint224 value) internal returns (uint224, uint224) {\\n return _insert(self._checkpoints, key, value);\\n }\\n\\n /**\\n * @dev Returns the value in the first (oldest) checkpoint with key greater or equal than the search key, or zero if\\n * there is none.\\n */\\n function lowerLookup(Trace224 storage self, uint32 key) internal view returns (uint224) {\\n uint256 len = self._checkpoints.length;\\n uint256 pos = _lowerBinaryLookup(self._checkpoints, key, 0, len);\\n return pos == len ? 0 : _unsafeAccess(self._checkpoints, pos)._value;\\n }\\n\\n /**\\n * @dev Returns the value in the last (most recent) checkpoint with key lower or equal than the search key, or zero\\n * if there is none.\\n */\\n function upperLookup(Trace224 storage self, uint32 key) internal view returns (uint224) {\\n uint256 len = self._checkpoints.length;\\n uint256 pos = _upperBinaryLookup(self._checkpoints, key, 0, len);\\n return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value;\\n }\\n\\n /**\\n * @dev Returns the value in the last (most recent) checkpoint with key lower or equal than the search key, or zero\\n * if there is none.\\n *\\n * NOTE: This is a variant of {upperLookup} that is optimised to find \\\"recent\\\" checkpoint (checkpoints with high\\n * keys).\\n */\\n function upperLookupRecent(Trace224 storage self, uint32 key) internal view returns (uint224) {\\n uint256 len = self._checkpoints.length;\\n\\n uint256 low = 0;\\n uint256 high = len;\\n\\n if (len > 5) {\\n uint256 mid = len - Math.sqrt(len);\\n if (key < _unsafeAccess(self._checkpoints, mid)._key) {\\n high = mid;\\n } else {\\n low = mid + 1;\\n }\\n }\\n\\n uint256 pos = _upperBinaryLookup(self._checkpoints, key, low, high);\\n\\n return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value;\\n }\\n\\n /**\\n * @dev Returns the value in the most recent checkpoint, or zero if there are no checkpoints.\\n */\\n function latest(Trace224 storage self) internal view returns (uint224) {\\n uint256 pos = self._checkpoints.length;\\n return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value;\\n }\\n\\n /**\\n * @dev Returns whether there is a checkpoint in the structure (i.e. it is not empty), and if so the key and value\\n * in the most recent checkpoint.\\n */\\n function latestCheckpoint(Trace224 storage self) internal view returns (bool exists, uint32 _key, uint224 _value) {\\n uint256 pos = self._checkpoints.length;\\n if (pos == 0) {\\n return (false, 0, 0);\\n } else {\\n Checkpoint224 memory ckpt = _unsafeAccess(self._checkpoints, pos - 1);\\n return (true, ckpt._key, ckpt._value);\\n }\\n }\\n\\n /**\\n * @dev Returns the number of checkpoint.\\n */\\n function length(Trace224 storage self) internal view returns (uint256) {\\n return self._checkpoints.length;\\n }\\n\\n /**\\n * @dev Returns checkpoint at given position.\\n */\\n function at(Trace224 storage self, uint32 pos) internal view returns (Checkpoint224 memory) {\\n return self._checkpoints[pos];\\n }\\n\\n /**\\n * @dev Pushes a (`key`, `value`) pair into an ordered list of checkpoints, either by inserting a new checkpoint,\\n * or by updating the last one.\\n */\\n function _insert(Checkpoint224[] storage self, uint32 key, uint224 value) private returns (uint224, uint224) {\\n uint256 pos = self.length;\\n\\n if (pos > 0) {\\n // Copying to memory is important here.\\n Checkpoint224 memory last = _unsafeAccess(self, pos - 1);\\n\\n // Checkpoint keys must be non-decreasing.\\n if (last._key > key) {\\n revert CheckpointUnorderedInsertion();\\n }\\n\\n // Update or push new checkpoint\\n if (last._key == key) {\\n _unsafeAccess(self, pos - 1)._value = value;\\n } else {\\n self.push(Checkpoint224({_key: key, _value: value}));\\n }\\n return (last._value, value);\\n } else {\\n self.push(Checkpoint224({_key: key, _value: value}));\\n return (0, value);\\n }\\n }\\n\\n /**\\n * @dev Return the index of the last (most recent) checkpoint with key lower or equal than the search key, or `high`\\n * if there is none. `low` and `high` define a section where to do the search, with inclusive `low` and exclusive\\n * `high`.\\n *\\n * WARNING: `high` should not be greater than the array's length.\\n */\\n function _upperBinaryLookup(\\n Checkpoint224[] storage self,\\n uint32 key,\\n uint256 low,\\n uint256 high\\n ) private view returns (uint256) {\\n while (low < high) {\\n uint256 mid = Math.average(low, high);\\n if (_unsafeAccess(self, mid)._key > key) {\\n high = mid;\\n } else {\\n low = mid + 1;\\n }\\n }\\n return high;\\n }\\n\\n /**\\n * @dev Return the index of the first (oldest) checkpoint with key is greater or equal than the search key, or\\n * `high` if there is none. `low` and `high` define a section where to do the search, with inclusive `low` and\\n * exclusive `high`.\\n *\\n * WARNING: `high` should not be greater than the array's length.\\n */\\n function _lowerBinaryLookup(\\n Checkpoint224[] storage self,\\n uint32 key,\\n uint256 low,\\n uint256 high\\n ) private view returns (uint256) {\\n while (low < high) {\\n uint256 mid = Math.average(low, high);\\n if (_unsafeAccess(self, mid)._key < key) {\\n low = mid + 1;\\n } else {\\n high = mid;\\n }\\n }\\n return high;\\n }\\n\\n /**\\n * @dev Access an element of the array without performing bounds check. The position is assumed to be within bounds.\\n */\\n function _unsafeAccess(\\n Checkpoint224[] storage self,\\n uint256 pos\\n ) private pure returns (Checkpoint224 storage result) {\\n assembly {\\n mstore(0, self.slot)\\n result.slot := add(keccak256(0, 0x20), pos)\\n }\\n }\\n\\n struct Trace208 {\\n Checkpoint208[] _checkpoints;\\n }\\n\\n struct Checkpoint208 {\\n uint48 _key;\\n uint208 _value;\\n }\\n\\n /**\\n * @dev Pushes a (`key`, `value`) pair into a Trace208 so that it is stored as the checkpoint.\\n *\\n * Returns previous value and new value.\\n *\\n * IMPORTANT: Never accept `key` as a user input, since an arbitrary `type(uint48).max` key set will disable the\\n * library.\\n */\\n function push(Trace208 storage self, uint48 key, uint208 value) internal returns (uint208, uint208) {\\n return _insert(self._checkpoints, key, value);\\n }\\n\\n /**\\n * @dev Returns the value in the first (oldest) checkpoint with key greater or equal than the search key, or zero if\\n * there is none.\\n */\\n function lowerLookup(Trace208 storage self, uint48 key) internal view returns (uint208) {\\n uint256 len = self._checkpoints.length;\\n uint256 pos = _lowerBinaryLookup(self._checkpoints, key, 0, len);\\n return pos == len ? 0 : _unsafeAccess(self._checkpoints, pos)._value;\\n }\\n\\n /**\\n * @dev Returns the value in the last (most recent) checkpoint with key lower or equal than the search key, or zero\\n * if there is none.\\n */\\n function upperLookup(Trace208 storage self, uint48 key) internal view returns (uint208) {\\n uint256 len = self._checkpoints.length;\\n uint256 pos = _upperBinaryLookup(self._checkpoints, key, 0, len);\\n return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value;\\n }\\n\\n /**\\n * @dev Returns the value in the last (most recent) checkpoint with key lower or equal than the search key, or zero\\n * if there is none.\\n *\\n * NOTE: This is a variant of {upperLookup} that is optimised to find \\\"recent\\\" checkpoint (checkpoints with high\\n * keys).\\n */\\n function upperLookupRecent(Trace208 storage self, uint48 key) internal view returns (uint208) {\\n uint256 len = self._checkpoints.length;\\n\\n uint256 low = 0;\\n uint256 high = len;\\n\\n if (len > 5) {\\n uint256 mid = len - Math.sqrt(len);\\n if (key < _unsafeAccess(self._checkpoints, mid)._key) {\\n high = mid;\\n } else {\\n low = mid + 1;\\n }\\n }\\n\\n uint256 pos = _upperBinaryLookup(self._checkpoints, key, low, high);\\n\\n return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value;\\n }\\n\\n /**\\n * @dev Returns the value in the most recent checkpoint, or zero if there are no checkpoints.\\n */\\n function latest(Trace208 storage self) internal view returns (uint208) {\\n uint256 pos = self._checkpoints.length;\\n return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value;\\n }\\n\\n /**\\n * @dev Returns whether there is a checkpoint in the structure (i.e. it is not empty), and if so the key and value\\n * in the most recent checkpoint.\\n */\\n function latestCheckpoint(Trace208 storage self) internal view returns (bool exists, uint48 _key, uint208 _value) {\\n uint256 pos = self._checkpoints.length;\\n if (pos == 0) {\\n return (false, 0, 0);\\n } else {\\n Checkpoint208 memory ckpt = _unsafeAccess(self._checkpoints, pos - 1);\\n return (true, ckpt._key, ckpt._value);\\n }\\n }\\n\\n /**\\n * @dev Returns the number of checkpoint.\\n */\\n function length(Trace208 storage self) internal view returns (uint256) {\\n return self._checkpoints.length;\\n }\\n\\n /**\\n * @dev Returns checkpoint at given position.\\n */\\n function at(Trace208 storage self, uint32 pos) internal view returns (Checkpoint208 memory) {\\n return self._checkpoints[pos];\\n }\\n\\n /**\\n * @dev Pushes a (`key`, `value`) pair into an ordered list of checkpoints, either by inserting a new checkpoint,\\n * or by updating the last one.\\n */\\n function _insert(Checkpoint208[] storage self, uint48 key, uint208 value) private returns (uint208, uint208) {\\n uint256 pos = self.length;\\n\\n if (pos > 0) {\\n // Copying to memory is important here.\\n Checkpoint208 memory last = _unsafeAccess(self, pos - 1);\\n\\n // Checkpoint keys must be non-decreasing.\\n if (last._key > key) {\\n revert CheckpointUnorderedInsertion();\\n }\\n\\n // Update or push new checkpoint\\n if (last._key == key) {\\n _unsafeAccess(self, pos - 1)._value = value;\\n } else {\\n self.push(Checkpoint208({_key: key, _value: value}));\\n }\\n return (last._value, value);\\n } else {\\n self.push(Checkpoint208({_key: key, _value: value}));\\n return (0, value);\\n }\\n }\\n\\n /**\\n * @dev Return the index of the last (most recent) checkpoint with key lower or equal than the search key, or `high`\\n * if there is none. `low` and `high` define a section where to do the search, with inclusive `low` and exclusive\\n * `high`.\\n *\\n * WARNING: `high` should not be greater than the array's length.\\n */\\n function _upperBinaryLookup(\\n Checkpoint208[] storage self,\\n uint48 key,\\n uint256 low,\\n uint256 high\\n ) private view returns (uint256) {\\n while (low < high) {\\n uint256 mid = Math.average(low, high);\\n if (_unsafeAccess(self, mid)._key > key) {\\n high = mid;\\n } else {\\n low = mid + 1;\\n }\\n }\\n return high;\\n }\\n\\n /**\\n * @dev Return the index of the first (oldest) checkpoint with key is greater or equal than the search key, or\\n * `high` if there is none. `low` and `high` define a section where to do the search, with inclusive `low` and\\n * exclusive `high`.\\n *\\n * WARNING: `high` should not be greater than the array's length.\\n */\\n function _lowerBinaryLookup(\\n Checkpoint208[] storage self,\\n uint48 key,\\n uint256 low,\\n uint256 high\\n ) private view returns (uint256) {\\n while (low < high) {\\n uint256 mid = Math.average(low, high);\\n if (_unsafeAccess(self, mid)._key < key) {\\n low = mid + 1;\\n } else {\\n high = mid;\\n }\\n }\\n return high;\\n }\\n\\n /**\\n * @dev Access an element of the array without performing bounds check. The position is assumed to be within bounds.\\n */\\n function _unsafeAccess(\\n Checkpoint208[] storage self,\\n uint256 pos\\n ) private pure returns (Checkpoint208 storage result) {\\n assembly {\\n mstore(0, self.slot)\\n result.slot := add(keccak256(0, 0x20), pos)\\n }\\n }\\n\\n struct Trace160 {\\n Checkpoint160[] _checkpoints;\\n }\\n\\n struct Checkpoint160 {\\n uint96 _key;\\n uint160 _value;\\n }\\n\\n /**\\n * @dev Pushes a (`key`, `value`) pair into a Trace160 so that it is stored as the checkpoint.\\n *\\n * Returns previous value and new value.\\n *\\n * IMPORTANT: Never accept `key` as a user input, since an arbitrary `type(uint96).max` key set will disable the\\n * library.\\n */\\n function push(Trace160 storage self, uint96 key, uint160 value) internal returns (uint160, uint160) {\\n return _insert(self._checkpoints, key, value);\\n }\\n\\n /**\\n * @dev Returns the value in the first (oldest) checkpoint with key greater or equal than the search key, or zero if\\n * there is none.\\n */\\n function lowerLookup(Trace160 storage self, uint96 key) internal view returns (uint160) {\\n uint256 len = self._checkpoints.length;\\n uint256 pos = _lowerBinaryLookup(self._checkpoints, key, 0, len);\\n return pos == len ? 0 : _unsafeAccess(self._checkpoints, pos)._value;\\n }\\n\\n /**\\n * @dev Returns the value in the last (most recent) checkpoint with key lower or equal than the search key, or zero\\n * if there is none.\\n */\\n function upperLookup(Trace160 storage self, uint96 key) internal view returns (uint160) {\\n uint256 len = self._checkpoints.length;\\n uint256 pos = _upperBinaryLookup(self._checkpoints, key, 0, len);\\n return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value;\\n }\\n\\n /**\\n * @dev Returns the value in the last (most recent) checkpoint with key lower or equal than the search key, or zero\\n * if there is none.\\n *\\n * NOTE: This is a variant of {upperLookup} that is optimised to find \\\"recent\\\" checkpoint (checkpoints with high\\n * keys).\\n */\\n function upperLookupRecent(Trace160 storage self, uint96 key) internal view returns (uint160) {\\n uint256 len = self._checkpoints.length;\\n\\n uint256 low = 0;\\n uint256 high = len;\\n\\n if (len > 5) {\\n uint256 mid = len - Math.sqrt(len);\\n if (key < _unsafeAccess(self._checkpoints, mid)._key) {\\n high = mid;\\n } else {\\n low = mid + 1;\\n }\\n }\\n\\n uint256 pos = _upperBinaryLookup(self._checkpoints, key, low, high);\\n\\n return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value;\\n }\\n\\n /**\\n * @dev Returns the value in the most recent checkpoint, or zero if there are no checkpoints.\\n */\\n function latest(Trace160 storage self) internal view returns (uint160) {\\n uint256 pos = self._checkpoints.length;\\n return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value;\\n }\\n\\n /**\\n * @dev Returns whether there is a checkpoint in the structure (i.e. it is not empty), and if so the key and value\\n * in the most recent checkpoint.\\n */\\n function latestCheckpoint(Trace160 storage self) internal view returns (bool exists, uint96 _key, uint160 _value) {\\n uint256 pos = self._checkpoints.length;\\n if (pos == 0) {\\n return (false, 0, 0);\\n } else {\\n Checkpoint160 memory ckpt = _unsafeAccess(self._checkpoints, pos - 1);\\n return (true, ckpt._key, ckpt._value);\\n }\\n }\\n\\n /**\\n * @dev Returns the number of checkpoint.\\n */\\n function length(Trace160 storage self) internal view returns (uint256) {\\n return self._checkpoints.length;\\n }\\n\\n /**\\n * @dev Returns checkpoint at given position.\\n */\\n function at(Trace160 storage self, uint32 pos) internal view returns (Checkpoint160 memory) {\\n return self._checkpoints[pos];\\n }\\n\\n /**\\n * @dev Pushes a (`key`, `value`) pair into an ordered list of checkpoints, either by inserting a new checkpoint,\\n * or by updating the last one.\\n */\\n function _insert(Checkpoint160[] storage self, uint96 key, uint160 value) private returns (uint160, uint160) {\\n uint256 pos = self.length;\\n\\n if (pos > 0) {\\n // Copying to memory is important here.\\n Checkpoint160 memory last = _unsafeAccess(self, pos - 1);\\n\\n // Checkpoint keys must be non-decreasing.\\n if (last._key > key) {\\n revert CheckpointUnorderedInsertion();\\n }\\n\\n // Update or push new checkpoint\\n if (last._key == key) {\\n _unsafeAccess(self, pos - 1)._value = value;\\n } else {\\n self.push(Checkpoint160({_key: key, _value: value}));\\n }\\n return (last._value, value);\\n } else {\\n self.push(Checkpoint160({_key: key, _value: value}));\\n return (0, value);\\n }\\n }\\n\\n /**\\n * @dev Return the index of the last (most recent) checkpoint with key lower or equal than the search key, or `high`\\n * if there is none. `low` and `high` define a section where to do the search, with inclusive `low` and exclusive\\n * `high`.\\n *\\n * WARNING: `high` should not be greater than the array's length.\\n */\\n function _upperBinaryLookup(\\n Checkpoint160[] storage self,\\n uint96 key,\\n uint256 low,\\n uint256 high\\n ) private view returns (uint256) {\\n while (low < high) {\\n uint256 mid = Math.average(low, high);\\n if (_unsafeAccess(self, mid)._key > key) {\\n high = mid;\\n } else {\\n low = mid + 1;\\n }\\n }\\n return high;\\n }\\n\\n /**\\n * @dev Return the index of the first (oldest) checkpoint with key is greater or equal than the search key, or\\n * `high` if there is none. `low` and `high` define a section where to do the search, with inclusive `low` and\\n * exclusive `high`.\\n *\\n * WARNING: `high` should not be greater than the array's length.\\n */\\n function _lowerBinaryLookup(\\n Checkpoint160[] storage self,\\n uint96 key,\\n uint256 low,\\n uint256 high\\n ) private view returns (uint256) {\\n while (low < high) {\\n uint256 mid = Math.average(low, high);\\n if (_unsafeAccess(self, mid)._key < key) {\\n low = mid + 1;\\n } else {\\n high = mid;\\n }\\n }\\n return high;\\n }\\n\\n /**\\n * @dev Access an element of the array without performing bounds check. The position is assumed to be within bounds.\\n */\\n function _unsafeAccess(\\n Checkpoint160[] storage self,\\n uint256 pos\\n ) private pure returns (Checkpoint160 storage result) {\\n assembly {\\n mstore(0, self.slot)\\n result.slot := add(keccak256(0, 0x20), pos)\\n }\\n }\\n}\\n\",\"keccak256\":\"0xbdc5e074d7dd6678f67e92b1a51a20226801a407b0e1af3da367c5d1ff4519ad\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/structs/DoubleEndedQueue.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/structs/DoubleEndedQueue.sol)\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev A sequence of items with the ability to efficiently push and pop items (i.e. insert and remove) on both ends of\\n * the sequence (called front and back). Among other access patterns, it can be used to implement efficient LIFO and\\n * FIFO queues. Storage use is optimized, and all operations are O(1) constant time. This includes {clear}, given that\\n * the existing queue contents are left in storage.\\n *\\n * The struct is called `Bytes32Deque`. Other types can be cast to and from `bytes32`. This data structure can only be\\n * used in storage, and not in memory.\\n * ```solidity\\n * DoubleEndedQueue.Bytes32Deque queue;\\n * ```\\n */\\nlibrary DoubleEndedQueue {\\n /**\\n * @dev An operation (e.g. {front}) couldn't be completed due to the queue being empty.\\n */\\n error QueueEmpty();\\n\\n /**\\n * @dev A push operation couldn't be completed due to the queue being full.\\n */\\n error QueueFull();\\n\\n /**\\n * @dev An operation (e.g. {at}) couldn't be completed due to an index being out of bounds.\\n */\\n error QueueOutOfBounds();\\n\\n /**\\n * @dev Indices are 128 bits so begin and end are packed in a single storage slot for efficient access.\\n *\\n * Struct members have an underscore prefix indicating that they are \\\"private\\\" and should not be read or written to\\n * directly. Use the functions provided below instead. Modifying the struct manually may violate assumptions and\\n * lead to unexpected behavior.\\n *\\n * The first item is at data[begin] and the last item is at data[end - 1]. This range can wrap around.\\n */\\n struct Bytes32Deque {\\n uint128 _begin;\\n uint128 _end;\\n mapping(uint128 index => bytes32) _data;\\n }\\n\\n /**\\n * @dev Inserts an item at the end of the queue.\\n *\\n * Reverts with {QueueFull} if the queue is full.\\n */\\n function pushBack(Bytes32Deque storage deque, bytes32 value) internal {\\n unchecked {\\n uint128 backIndex = deque._end;\\n if (backIndex + 1 == deque._begin) revert QueueFull();\\n deque._data[backIndex] = value;\\n deque._end = backIndex + 1;\\n }\\n }\\n\\n /**\\n * @dev Removes the item at the end of the queue and returns it.\\n *\\n * Reverts with {QueueEmpty} if the queue is empty.\\n */\\n function popBack(Bytes32Deque storage deque) internal returns (bytes32 value) {\\n unchecked {\\n uint128 backIndex = deque._end;\\n if (backIndex == deque._begin) revert QueueEmpty();\\n --backIndex;\\n value = deque._data[backIndex];\\n delete deque._data[backIndex];\\n deque._end = backIndex;\\n }\\n }\\n\\n /**\\n * @dev Inserts an item at the beginning of the queue.\\n *\\n * Reverts with {QueueFull} if the queue is full.\\n */\\n function pushFront(Bytes32Deque storage deque, bytes32 value) internal {\\n unchecked {\\n uint128 frontIndex = deque._begin - 1;\\n if (frontIndex == deque._end) revert QueueFull();\\n deque._data[frontIndex] = value;\\n deque._begin = frontIndex;\\n }\\n }\\n\\n /**\\n * @dev Removes the item at the beginning of the queue and returns it.\\n *\\n * Reverts with `QueueEmpty` if the queue is empty.\\n */\\n function popFront(Bytes32Deque storage deque) internal returns (bytes32 value) {\\n unchecked {\\n uint128 frontIndex = deque._begin;\\n if (frontIndex == deque._end) revert QueueEmpty();\\n value = deque._data[frontIndex];\\n delete deque._data[frontIndex];\\n deque._begin = frontIndex + 1;\\n }\\n }\\n\\n /**\\n * @dev Returns the item at the beginning of the queue.\\n *\\n * Reverts with `QueueEmpty` if the queue is empty.\\n */\\n function front(Bytes32Deque storage deque) internal view returns (bytes32 value) {\\n if (empty(deque)) revert QueueEmpty();\\n return deque._data[deque._begin];\\n }\\n\\n /**\\n * @dev Returns the item at the end of the queue.\\n *\\n * Reverts with `QueueEmpty` if the queue is empty.\\n */\\n function back(Bytes32Deque storage deque) internal view returns (bytes32 value) {\\n if (empty(deque)) revert QueueEmpty();\\n unchecked {\\n return deque._data[deque._end - 1];\\n }\\n }\\n\\n /**\\n * @dev Return the item at a position in the queue given by `index`, with the first item at 0 and last item at\\n * `length(deque) - 1`.\\n *\\n * Reverts with `QueueOutOfBounds` if the index is out of bounds.\\n */\\n function at(Bytes32Deque storage deque, uint256 index) internal view returns (bytes32 value) {\\n if (index >= length(deque)) revert QueueOutOfBounds();\\n // By construction, length is a uint128, so the check above ensures that index can be safely downcast to uint128\\n unchecked {\\n return deque._data[deque._begin + uint128(index)];\\n }\\n }\\n\\n /**\\n * @dev Resets the queue back to being empty.\\n *\\n * NOTE: The current items are left behind in storage. This does not affect the functioning of the queue, but misses\\n * out on potential gas refunds.\\n */\\n function clear(Bytes32Deque storage deque) internal {\\n deque._begin = 0;\\n deque._end = 0;\\n }\\n\\n /**\\n * @dev Returns the number of items in the queue.\\n */\\n function length(Bytes32Deque storage deque) internal view returns (uint256) {\\n unchecked {\\n return uint256(deque._end - deque._begin);\\n }\\n }\\n\\n /**\\n * @dev Returns true if the queue is empty.\\n */\\n function empty(Bytes32Deque storage deque) internal view returns (bool) {\\n return deque._end == deque._begin;\\n }\\n}\\n\",\"keccak256\":\"0xed6b702230a66640a0f1dd96106dd697e821b6b0fbb2eeab1c09d88d7c411a67\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/types/Time.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/types/Time.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Math} from \\\"../math/Math.sol\\\";\\nimport {SafeCast} from \\\"../math/SafeCast.sol\\\";\\n\\n/**\\n * @dev This library provides helpers for manipulating time-related objects.\\n *\\n * It uses the following types:\\n * - `uint48` for timepoints\\n * - `uint32` for durations\\n *\\n * While the library doesn't provide specific types for timepoints and duration, it does provide:\\n * - a `Delay` type to represent duration that can be programmed to change value automatically at a given point\\n * - additional helper functions\\n */\\nlibrary Time {\\n using Time for *;\\n\\n /**\\n * @dev Get the block timestamp as a Timepoint.\\n */\\n function timestamp() internal view returns (uint48) {\\n return SafeCast.toUint48(block.timestamp);\\n }\\n\\n /**\\n * @dev Get the block number as a Timepoint.\\n */\\n function blockNumber() internal view returns (uint48) {\\n return SafeCast.toUint48(block.number);\\n }\\n\\n // ==================================================== Delay =====================================================\\n /**\\n * @dev A `Delay` is a uint32 duration that can be programmed to change value automatically at a given point in the\\n * future. The \\\"effect\\\" timepoint describes when the transitions happens from the \\\"old\\\" value to the \\\"new\\\" value.\\n * This allows updating the delay applied to some operation while keeping some guarantees.\\n *\\n * In particular, the {update} function guarantees that if the delay is reduced, the old delay still applies for\\n * some time. For example if the delay is currently 7 days to do an upgrade, the admin should not be able to set\\n * the delay to 0 and upgrade immediately. If the admin wants to reduce the delay, the old delay (7 days) should\\n * still apply for some time.\\n *\\n *\\n * The `Delay` type is 112 bits long, and packs the following:\\n *\\n * ```\\n * | [uint48]: effect date (timepoint)\\n * | | [uint32]: value before (duration)\\n * \\u2193 \\u2193 \\u2193 [uint32]: value after (duration)\\n * 0xAAAAAAAAAAAABBBBBBBBCCCCCCCC\\n * ```\\n *\\n * NOTE: The {get} and {withUpdate} functions operate using timestamps. Block number based delays are not currently\\n * supported.\\n */\\n type Delay is uint112;\\n\\n /**\\n * @dev Wrap a duration into a Delay to add the one-step \\\"update in the future\\\" feature\\n */\\n function toDelay(uint32 duration) internal pure returns (Delay) {\\n return Delay.wrap(duration);\\n }\\n\\n /**\\n * @dev Get the value at a given timepoint plus the pending value and effect timepoint if there is a scheduled\\n * change after this timepoint. If the effect timepoint is 0, then the pending value should not be considered.\\n */\\n function _getFullAt(Delay self, uint48 timepoint) private pure returns (uint32, uint32, uint48) {\\n (uint32 valueBefore, uint32 valueAfter, uint48 effect) = self.unpack();\\n return effect <= timepoint ? (valueAfter, 0, 0) : (valueBefore, valueAfter, effect);\\n }\\n\\n /**\\n * @dev Get the current value plus the pending value and effect timepoint if there is a scheduled change. If the\\n * effect timepoint is 0, then the pending value should not be considered.\\n */\\n function getFull(Delay self) internal view returns (uint32, uint32, uint48) {\\n return _getFullAt(self, timestamp());\\n }\\n\\n /**\\n * @dev Get the current value.\\n */\\n function get(Delay self) internal view returns (uint32) {\\n (uint32 delay, , ) = self.getFull();\\n return delay;\\n }\\n\\n /**\\n * @dev Update a Delay object so that it takes a new duration after a timepoint that is automatically computed to\\n * enforce the old delay at the moment of the update. Returns the updated Delay object and the timestamp when the\\n * new delay becomes effective.\\n */\\n function withUpdate(\\n Delay self,\\n uint32 newValue,\\n uint32 minSetback\\n ) internal view returns (Delay updatedDelay, uint48 effect) {\\n uint32 value = self.get();\\n uint32 setback = uint32(Math.max(minSetback, value > newValue ? value - newValue : 0));\\n effect = timestamp() + setback;\\n return (pack(value, newValue, effect), effect);\\n }\\n\\n /**\\n * @dev Split a delay into its components: valueBefore, valueAfter and effect (transition timepoint).\\n */\\n function unpack(Delay self) internal pure returns (uint32 valueBefore, uint32 valueAfter, uint48 effect) {\\n uint112 raw = Delay.unwrap(self);\\n\\n valueAfter = uint32(raw);\\n valueBefore = uint32(raw >> 32);\\n effect = uint48(raw >> 64);\\n\\n return (valueBefore, valueAfter, effect);\\n }\\n\\n /**\\n * @dev pack the components into a Delay object.\\n */\\n function pack(uint32 valueBefore, uint32 valueAfter, uint48 effect) internal pure returns (Delay) {\\n return Delay.wrap((uint112(effect) << 64) | (uint112(valueBefore) << 32) | uint112(valueAfter));\\n }\\n}\\n\",\"keccak256\":\"0xc7755af115020049e4140f224f9ee88d7e1799ffb0646f37bf0df24bf6213f58\",\"license\":\"MIT\"},\"contracts/DevRewardDistributor.sol\":{\"content\":\"// SPDX-License-Identifier: Apache-2.0\\n\\npragma solidity >=0.8.15;\\n\\nimport \\\"./FluenceToken.sol\\\";\\nimport \\\"./Executor.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/cryptography/ECDSA.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/cryptography/MerkleProof.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\n/**\\n * @title DevRewardDistributor\\n * @notice Contract for managing developers reward\\n */\\ncontract DevRewardDistributor {\\n using SafeERC20 for IERC20;\\n\\n struct LockedBalance {\\n uint256 amount;\\n uint256 unlockTime;\\n }\\n\\n /**\\n * @notice Reward token\\n *\\n */\\n FluenceToken public immutable token;\\n\\n /**\\n * @notice DAO timelock contract address\\n *\\n */\\n Executor public immutable executor;\\n\\n /**\\n * @notice Canceler address (e.g. FluenceMultisig)\\n *\\n */\\n address public immutable canceler;\\n\\n /**\\n * @notice Claiming end time\\n *\\n */\\n uint256 public immutable claimingEndTime;\\n\\n /**\\n * @notice Time when this contract was deployed\\n *\\n */\\n uint256 public immutable deployTime;\\n\\n /**\\n * @notice Merkle root from rewards tree\\n *\\n */\\n bytes32 public immutable merkleRoot;\\n\\n /**\\n * @notice Period for dividing the reward\\n *\\n */\\n uint256 public immutable halvePeriod;\\n\\n /**\\n * @notice Returns the vesting contract decimals\\n *\\n */\\n uint8 public immutable decimals;\\n\\n /**\\n * @notice Initial user's reward\\n *\\n */\\n uint256 public immutable initialReward;\\n\\n uint256 public immutable lockupPeriod;\\n\\n uint256 public immutable maxClaimedSupply;\\n\\n uint256 public claimedSupply;\\n\\n uint256 private _totalSupply;\\n\\n /**\\n * @notice Bitmap with claimed users ids\\n *\\n */\\n mapping(uint256 => uint256) private claimedBitMap;\\n\\n mapping(address => LockedBalance) public lockedBalances;\\n\\n /**\\n * @notice Emitted when user claims reward\\n * @param userId - reward user id\\n * @param account - reward account\\n * @param amount - reward amount\\n * @param leaf - leaf with user's info in reward tree\\n *\\n */\\n event Claimed(uint256 indexed userId, address account, uint256 amount, bytes32 leaf);\\n\\n /**\\n * @notice Emitted when claiming period is ended and tokens transfer to the executor\\n * @param amount - remainder balance\\n *\\n */\\n event TransferUnclaimed(uint256 amount);\\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 * @param _token - reward token\\n * @param _executor - DAO timelock contract\\n * @param _merkleRoot - merkle root from rewards tree\\n * @param _halvePeriod - period for dividing the reward\\n * @param _initialReward - initial user reward\\n * @param _claimingPeriod - claiming period\\n * @param _canceler - can cancel distribution, and withdraw to _executor.\\n *\\n */\\n constructor(\\n FluenceToken _token,\\n Executor _executor,\\n bytes32 _merkleRoot,\\n uint256 _halvePeriod,\\n uint256 _lockupPeriod,\\n uint256 _initialReward,\\n uint256 _claimingPeriod,\\n address _canceler,\\n uint256 _maxClaimedSupply\\n ) {\\n token = _token;\\n executor = _executor;\\n canceler = _canceler;\\n\\n merkleRoot = _merkleRoot;\\n halvePeriod = _halvePeriod;\\n lockupPeriod = _lockupPeriod;\\n initialReward = _initialReward;\\n\\n deployTime = block.timestamp;\\n claimingEndTime = block.timestamp + _claimingPeriod;\\n\\n maxClaimedSupply = _maxClaimedSupply;\\n\\n decimals = _token.decimals();\\n }\\n\\n modifier whenClaimingIs(bool isActive) {\\n require(isClaimingActive() == isActive, \\\"Claiming status is not as expected\\\");\\n _;\\n }\\n\\n function name() external view returns (string memory) {\\n return \\\"Fluence Drop\\\";\\n }\\n\\n function symbol() external view returns (string memory) {\\n return \\\"FLT-DROP\\\";\\n }\\n\\n function totalSupply() external view returns (uint256) {\\n return _totalSupply;\\n }\\n\\n function balanceOf(address account) external view returns (uint256) {\\n return lockedBalances[account].amount;\\n }\\n\\n function transfer(address to, uint256 value) external returns (bool) {\\n require(value > 0, \\\"Value is 0\\\");\\n require(lockedBalances[msg.sender].amount == value, \\\"Invalid amount\\\");\\n require(block.timestamp > lockedBalances[msg.sender].unlockTime, \\\"Tokens are locked\\\");\\n\\n lockedBalances[msg.sender].amount = 0;\\n _totalSupply -= value;\\n IERC20(token).safeTransfer(msg.sender, value);\\n emit Transfer(msg.sender, address(0x00), value);\\n\\n return true;\\n }\\n\\n /**\\n * @notice Claim reward token\\n * @param userId - user id in merkle tree\\n * @param merkleProof - merkle proof for leaf\\n * @param temporaryAddress - temporary Ethereum address that's used only for signing\\n * @param signature - signature of temporary Ethereum address\\n *\\n */\\n function claimTokens(\\n uint32 userId,\\n bytes32[] calldata merkleProof,\\n address temporaryAddress,\\n bytes calldata signature\\n ) external whenClaimingIs(true) {\\n require(!isClaimed(userId), \\\"Tokens already claimed\\\");\\n require(lockedBalances[msg.sender].unlockTime == 0, \\\"Tokens are already locked\\\");\\n\\n uint256 amount = currentReward();\\n uint256 claimedSupply_ = claimedSupply;\\n\\n require(claimedSupply_ + amount <= maxClaimedSupply, \\\"Total claimed exceeded max limit\\\");\\n\\n bytes32 leaf = keccak256(abi.encodePacked(userId, temporaryAddress));\\n\\n require(MerkleProof.verify(merkleProof, merkleRoot, leaf), \\\"Valid proof required\\\");\\n\\n bytes32 msgHash = keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n20\\\", msg.sender));\\n\\n address signer = ECDSA.recover(msgHash, signature);\\n require(signer == temporaryAddress, \\\"Invalid signature\\\");\\n\\n _setClaimed(userId);\\n\\n lockedBalances[msg.sender] = LockedBalance({amount: amount, unlockTime: block.timestamp + lockupPeriod});\\n _totalSupply += amount;\\n claimedSupply = claimedSupply_ + amount;\\n\\n emit Transfer(address(0x00), msg.sender, amount);\\n emit Claimed(userId, msg.sender, amount, leaf);\\n }\\n\\n /**\\n * @notice used to move any remaining tokens out of the contract to Executor (DAO) in emergency situation.\\n *\\n */\\n function withdraw() external {\\n require(msg.sender == canceler, \\\"Caller is not a canceler\\\");\\n\\n IERC20 rewardToken = IERC20(token); //gas saving\\n\\n uint256 remainingBalance = rewardToken.balanceOf(address(this));\\n rewardToken.safeTransfer(address(executor), remainingBalance);\\n\\n emit TransferUnclaimed(remainingBalance);\\n }\\n\\n /**\\n * @notice checks claimed bitMap for userId\\n * @dev fork from uniswap merkle distributor, unmodified\\n * @return - boolean\\n *\\n */\\n function isClaimed(uint256 index) public view returns (bool) {\\n uint256 claimedWordIndex = index / 256;\\n uint256 claimedBitIndex = index % 256;\\n uint256 claimedWord = claimedBitMap[claimedWordIndex];\\n uint256 mask = (1 << claimedBitIndex);\\n return claimedWord & mask == mask;\\n }\\n\\n /**\\n * @notice Checking if claiming is active\\n * @return - boolean\\n *\\n */\\n function isClaimingActive() public view returns (bool) {\\n return block.timestamp < claimingEndTime;\\n }\\n\\n /**\\n * @notice Get current user's reward\\n * @return - boolean\\n *\\n */\\n function currentReward() public view returns (uint256) {\\n if (!isClaimingActive()) {\\n return 0;\\n }\\n\\n uint256 halveTimes = (block.timestamp - deployTime) / halvePeriod;\\n uint256 denominator = 2 ** halveTimes;\\n\\n return initialReward / denominator;\\n }\\n\\n /**\\n * @notice Sets a given user by index to claimed\\n * @dev taken from uniswap merkle distributor, unmodified\\n *\\n */\\n function _setClaimed(uint256 index) private {\\n uint256 claimedWordIndex = index / 256;\\n uint256 claimedBitIndex = index % 256;\\n claimedBitMap[claimedWordIndex] = claimedBitMap[claimedWordIndex] | (1 << claimedBitIndex);\\n }\\n}\\n\",\"keccak256\":\"0xc3581c48145996a3c2284a5cc724774b60e38490b048d2a87f6c367ba896fab9\",\"license\":\"Apache-2.0\"},\"contracts/Executor.sol\":{\"content\":\"// SPDX-License-Identifier: Apache-2.0\\n\\npragma solidity >=0.8.15;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/governance/TimelockControllerUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\\\";\\nimport \\\"./Governor.sol\\\";\\n\\n/**\\n * @title Executor\\n * @notice DAO timelock contract. This contract is called Executor because all successful DAO proposals results flow through it.\\n */\\ncontract Executor is TimelockControllerUpgradeable, UUPSUpgradeable {\\n /// @custom:oz-upgrades-unsafe-allow constructor\\n constructor() {\\n _disableInitializers();\\n }\\n\\n /**\\n * @notice Constructor for this updatable contract\\n * @param minDelay - minimal delay time for timelock\\n **/\\n function initialize(uint256 minDelay) public initializer {\\n __UUPSUpgradeable_init();\\n __TimelockController_init(\\n minDelay,\\n new address[](0),\\n new address[](1),\\n msg.sender\\n );\\n }\\n\\n function _authorizeUpgrade(\\n address /*newImplementation*/\\n ) internal view override {\\n require(\\n msg.sender == address(this),\\n \\\"Only this contract can authorize an upgrade\\\"\\n );\\n }\\n}\\n\",\"keccak256\":\"0x76d003a0c6de45f4371263e995ecf9122b069efcb9bd6c562edacd2f4736d0db\",\"license\":\"Apache-2.0\"},\"contracts/FluenceToken.sol\":{\"content\":\"// SPDX-License-Identifier: Apache-2.0\\n\\npragma solidity >=0.8.15;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20PermitUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20VotesUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\\\";\\n\\ncontract FluenceToken is\\n ERC20Upgradeable,\\n ERC20PermitUpgradeable,\\n ERC20VotesUpgradeable,\\n OwnableUpgradeable,\\n UUPSUpgradeable\\n{\\n /// @custom:oz-upgrades-unsafe-allow constructor\\n constructor() {\\n _disableInitializers();\\n }\\n\\n function initialize(string memory name_, string memory symbol_, uint256 totalSupply_) public initializer {\\n __ERC20_init(name_, symbol_);\\n __ERC20Permit_init(name_);\\n __ERC20Votes_init();\\n\\n __Ownable_init(msg.sender);\\n __UUPSUpgradeable_init();\\n\\n _mint(msg.sender, totalSupply_);\\n }\\n\\n function _update(address from, address to, uint256 value)\\n internal\\n override(ERC20Upgradeable, ERC20VotesUpgradeable)\\n {\\n super._update(from, to, value);\\n }\\n\\n function nonces(address owner) public view override(ERC20PermitUpgradeable, NoncesUpgradeable) returns (uint256) {\\n return super.nonces(owner);\\n }\\n\\n function _authorizeUpgrade(address) internal override onlyOwner {}\\n}\\n\",\"keccak256\":\"0xaacc8412b22a1790b5c1e83426f00d2c188220fef9e344e637bcf8262b806518\",\"license\":\"Apache-2.0\"},\"contracts/Governor.sol\":{\"content\":\"// SPDX-License-Identifier: Apache-2.0\\n\\npragma solidity >=0.8.15;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/governance/GovernorUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/governance/extensions/GovernorSettingsUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/governance/extensions/GovernorCountingSimpleUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/governance/extensions/GovernorVotesUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/governance/extensions/GovernorVotesQuorumFractionUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/governance/extensions/GovernorTimelockControlUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol\\\";\\nimport \\\"./VestingWithVoting.sol\\\";\\nimport \\\"./Executor.sol\\\";\\n\\ncontract Governor is\\n Initializable,\\n GovernorUpgradeable,\\n GovernorSettingsUpgradeable,\\n GovernorCountingSimpleUpgradeable,\\n GovernorVotesUpgradeable,\\n GovernorVotesQuorumFractionUpgradeable,\\n GovernorTimelockControlUpgradeable,\\n UUPSUpgradeable\\n{\\n /**\\n * @notice Team vesting contract with voting functionality\\n **/\\n VestingWithVoting public teamVesting;\\n\\n /// @custom:oz-upgrades-unsafe-allow constructor\\n constructor() {\\n _disableInitializers();\\n }\\n\\n /**\\n * @notice Constructor for this updatable contract\\n * @param _token - token for managing this DAO\\n * @param teamVesting_ - team\\n * @param executor_ - DAO timelock contract\\n * @param quorum_ - minimum percentage of quorum to accept a proposal\\n * @param initialVotingDelay - delay between the creation of a proposal and the start of voting\\n * @param initialVotingPeriod - voting duration\\n * @param initialProposalThreshold - tokens threshold for creating a proposal\\n **/\\n function initialize(\\n IVotes _token,\\n VestingWithVoting teamVesting_,\\n Executor executor_,\\n uint256 quorum_,\\n uint32 initialVotingDelay,\\n uint32 initialVotingPeriod,\\n uint256 initialProposalThreshold\\n ) public initializer {\\n __UUPSUpgradeable_init();\\n __Governor_init(\\\"FluenceGovernor\\\");\\n __GovernorSettings_init(\\n initialVotingDelay,\\n initialVotingPeriod,\\n initialProposalThreshold\\n );\\n __GovernorCountingSimple_init();\\n __GovernorVotes_init(_token);\\n __GovernorVotesQuorumFraction_init(quorum_);\\n __GovernorTimelockControl_init(\\n TimelockControllerUpgradeable(executor_)\\n );\\n\\n teamVesting = teamVesting_;\\n }\\n\\n function _authorizeUpgrade(\\n address /*newImplementation*/\\n ) internal view override {\\n require(\\n msg.sender == timelock(),\\n \\\"Only the executor contract can authorize an upgrade\\\"\\n );\\n }\\n\\n function _getVotes(\\n address account,\\n uint256 blockNumber,\\n bytes memory params\\n )\\n internal\\n view\\n override(GovernorUpgradeable, GovernorVotesUpgradeable)\\n returns (uint256)\\n {\\n uint256 votes = teamVesting.getPastVotes(account, blockNumber);\\n\\n votes += super._getVotes(account, blockNumber, params);\\n\\n return votes;\\n }\\n\\n function votingDelay()\\n public\\n view\\n override(GovernorUpgradeable, GovernorSettingsUpgradeable)\\n returns (uint256)\\n {\\n return super.votingDelay();\\n }\\n\\n function votingPeriod()\\n public\\n view\\n override(GovernorUpgradeable, GovernorSettingsUpgradeable)\\n returns (uint256)\\n {\\n return super.votingPeriod();\\n }\\n\\n function quorum(\\n uint256 blockNumber\\n )\\n public\\n view\\n override(GovernorUpgradeable, GovernorVotesQuorumFractionUpgradeable)\\n returns (uint256)\\n {\\n return super.quorum(blockNumber);\\n }\\n\\n function state(\\n uint256 proposalId\\n )\\n public\\n view\\n override(GovernorUpgradeable, GovernorTimelockControlUpgradeable)\\n returns (ProposalState)\\n {\\n return super.state(proposalId);\\n }\\n\\n function proposalNeedsQueuing(\\n uint256 proposalId\\n )\\n public\\n view\\n override(GovernorUpgradeable, GovernorTimelockControlUpgradeable)\\n returns (bool)\\n {\\n return super.proposalNeedsQueuing(proposalId);\\n }\\n\\n function proposalThreshold()\\n public\\n view\\n override(GovernorUpgradeable, GovernorSettingsUpgradeable)\\n returns (uint256)\\n {\\n return super.proposalThreshold();\\n }\\n\\n function _queueOperations(\\n uint256 proposalId,\\n address[] memory targets,\\n uint256[] memory values,\\n bytes[] memory calldatas,\\n bytes32 descriptionHash\\n )\\n internal\\n override(GovernorUpgradeable, GovernorTimelockControlUpgradeable)\\n returns (uint48)\\n {\\n return\\n super._queueOperations(\\n proposalId,\\n targets,\\n values,\\n calldatas,\\n descriptionHash\\n );\\n }\\n\\n function _executeOperations(\\n uint256 proposalId,\\n address[] memory targets,\\n uint256[] memory values,\\n bytes[] memory calldatas,\\n bytes32 descriptionHash\\n )\\n internal\\n override(GovernorUpgradeable, GovernorTimelockControlUpgradeable)\\n {\\n super._executeOperations(\\n proposalId,\\n targets,\\n values,\\n calldatas,\\n descriptionHash\\n );\\n }\\n\\n function _cancel(\\n address[] memory targets,\\n uint256[] memory values,\\n bytes[] memory calldatas,\\n bytes32 descriptionHash\\n )\\n internal\\n override(GovernorUpgradeable, GovernorTimelockControlUpgradeable)\\n returns (uint256)\\n {\\n return super._cancel(targets, values, calldatas, descriptionHash);\\n }\\n\\n function _executor()\\n internal\\n view\\n override(GovernorUpgradeable, GovernorTimelockControlUpgradeable)\\n returns (address)\\n {\\n return super._executor();\\n }\\n}\\n\",\"keccak256\":\"0xa94fdc58cc45d43a5bcaef741133b4ed7e1fa68a9960e6fc829b0394656e677a\",\"license\":\"Apache-2.0\"},\"contracts/Vesting.sol\":{\"content\":\"// SPDX-License-Identifier: Apache-2.0\\n\\npragma solidity >=0.8.15;\\n\\nimport \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport \\\"./FluenceToken.sol\\\";\\n\\n/**\\n * @title Vesting with Delayed Start\\n * @notice Vesting Fluence token contract\\n * @dev This contract implements the ERC20 standard. It is possible to add the contract to a wallet. Transferring to zero address is unlocking the released amount.\\n */\\ncontract Vesting is IERC20 {\\n using SafeERC20 for IERC20;\\n\\n /**\\n * @notice Returns the vesting token\\n *\\n */\\n FluenceToken public immutable token;\\n\\n /**\\n * @notice Returns the start vesting time\\n *\\n */\\n uint256 public immutable startTimestamp;\\n\\n /**\\n * @notice Returns the vesting duration since vesting start\\n *\\n */\\n uint256 public immutable vestingDuration;\\n\\n /**\\n * @notice Returns the vesting contract decimals\\n *\\n */\\n uint8 public immutable decimals;\\n\\n bytes32 private immutable _name;\\n uint256 private immutable _nameLength;\\n\\n bytes32 private immutable _symbol;\\n uint256 private immutable _symbolLength;\\n\\n /**\\n * @notice Returns the locked vesting user's balance\\n *\\n */\\n mapping(address => uint256) public lockedBalances;\\n\\n /**\\n * @notice Returns the current vesting user's balance\\n *\\n */\\n mapping(address => uint256) public balanceOf;\\n\\n uint256 private _totalSupply;\\n\\n /**\\n * @notice constructor\\n * @param token_ - vesting token address\\n * @param name_ - vesting contract name\\n * @param symbol_ - vesting contract symbol\\n * @param _vestingDelay - delay before vesting start\\n * @param _vestingDuration - vesting duration\\n * @param accounts - vesting accounts\\n * @param amounts - vesting amounts of accounts\\n *\\n */\\n constructor(\\n FluenceToken token_,\\n string memory name_,\\n string memory symbol_,\\n uint256 _vestingDelay,\\n uint256 _vestingDuration,\\n address[] memory accounts,\\n uint256[] memory amounts\\n ) {\\n require(accounts.length == amounts.length, \\\"accounts and amounts must have the same length\\\");\\n\\n require(bytes(name_).length <= 31, \\\"invalid name length\\\");\\n require(bytes(symbol_).length <= 31, \\\"invalid symbol length\\\");\\n\\n startTimestamp = block.timestamp + _vestingDelay;\\n\\n vestingDuration = _vestingDuration;\\n\\n token = token_;\\n\\n _name = bytes32(bytes(name_));\\n _nameLength = bytes(name_).length;\\n\\n _symbol = bytes32(bytes(symbol_));\\n _symbolLength = bytes(symbol_).length;\\n\\n decimals = token.decimals();\\n\\n for (uint256 i = 0; i < accounts.length; i++) {\\n uint256 amount = amounts[i];\\n lockedBalances[accounts[i]] = amount;\\n balanceOf[accounts[i]] = amount;\\n _totalSupply += amount;\\n emit Transfer(address(0x00), accounts[i], amount);\\n }\\n }\\n\\n /**\\n * @notice Returns vesting contract name\\n *\\n */\\n function name() external view returns (string memory n) {\\n n = string(abi.encodePacked(_name));\\n uint256 length = _nameLength;\\n assembly {\\n mstore(n, length)\\n }\\n }\\n\\n /**\\n * @notice Returns vesting contract symbol\\n *\\n */\\n function symbol() external view returns (string memory s) {\\n s = string(abi.encodePacked(_symbol));\\n uint256 length = _symbolLength;\\n assembly {\\n mstore(s, length)\\n }\\n }\\n\\n /**\\n * @notice Get a available amount by user\\n * @return available amount\\n *\\n */\\n function getAvailableAmount(address account) public view returns (uint256) {\\n if (block.timestamp <= startTimestamp) {\\n return 0;\\n }\\n\\n uint256 totalTime = vestingDuration;\\n uint256 locked = lockedBalances[account];\\n uint256 released = locked - balanceOf[account];\\n\\n uint256 past = block.timestamp - startTimestamp;\\n\\n uint256 amount = 0;\\n if (past >= totalTime) {\\n amount = locked - released;\\n } else {\\n uint256 amountBySec = locked / totalTime;\\n amount = past * amountBySec - released;\\n }\\n\\n return amount;\\n }\\n\\n /**\\n * @notice Unsupported operation\\n *\\n */\\n function allowance(address owner, address spender) external view returns (uint256) {\\n return 0;\\n }\\n\\n /**\\n * @notice Returns total locked amount\\n *\\n */\\n function totalSupply() external view virtual override returns (uint256) {\\n return _totalSupply;\\n }\\n\\n /**\\n * @notice Returns released amount\\n * @param to - always address 0x00\\n * @param amount - the full released amount or part of it\\n *\\n */\\n function transfer(address to, uint256 amount) external returns (bool) {\\n require(to == address(0x00), \\\"Transfer allowed only to the zero address\\\");\\n\\n address sender = msg.sender;\\n _burn(sender, amount);\\n\\n emit Transfer(sender, to, amount);\\n return true;\\n }\\n\\n /**\\n * @notice Unsupported operation\\n *\\n */\\n function transferFrom(address from, address to, uint256 value) external returns (bool) {\\n revert(\\\"Unsupported operation\\\");\\n }\\n\\n /**\\n * @notice Unsupported operation\\n *\\n */\\n function approve(address spender, uint256 amount) external returns (bool) {\\n revert(\\\"Unsupported operation\\\");\\n }\\n\\n function _burn(address from, uint256 amount) internal {\\n uint256 releaseAmount = getAvailableAmount(from);\\n\\n require(releaseAmount > 0, \\\"Not enough the release amount\\\");\\n\\n if (amount != 0) {\\n require(amount <= releaseAmount, \\\"Not enough the release amount\\\");\\n } else {\\n amount = releaseAmount;\\n }\\n\\n _beforeBurn(from, amount);\\n\\n balanceOf[from] -= amount;\\n _totalSupply -= amount;\\n\\n IERC20(token).safeTransfer(from, amount);\\n }\\n\\n function _beforeBurn(address from, uint256 amount) internal virtual {}\\n}\\n\",\"keccak256\":\"0x0ab141d92d05e37dcb447da5d1380f2f481f9dc760c730cb71d46effa325b315\",\"license\":\"Apache-2.0\"},\"contracts/VestingWithVoting.sol\":{\"content\":\"// SPDX-License-Identifier: Apache-2.0\\n\\npragma solidity >=0.8.15;\\n\\nimport \\\"@openzeppelin/contracts/governance/utils/Votes.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport \\\"./Vesting.sol\\\";\\nimport \\\"./FluenceToken.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/cryptography/EIP712.sol\\\";\\n\\n/**\\n * @title Vesting with voting\\n * @notice Vesting fluence token contract for team\\n * @dev This contract implements the ERC20 standard. It is possible to add the contract to a wallet. Transferring to zero address is unlocking the released amount.\\n * This contract is possible for voting when the token is vesting.\\n */\\ncontract VestingWithVoting is Vesting, Votes {\\n constructor(\\n FluenceToken token_,\\n string memory name_,\\n string memory symbol_,\\n uint256 vestingDelay_,\\n uint256 vestingDuration_,\\n address[] memory accounts,\\n uint256[] memory amounts\\n ) Vesting(token_, name_, symbol_, vestingDelay_, vestingDuration_, accounts, amounts) EIP712(name_, \\\"1\\\") {\\n for (uint256 i = 0; i < accounts.length; i++) {\\n address account = accounts[i];\\n _transferVotingUnits(address(0x00), account, amounts[i]);\\n _delegate(account, account);\\n }\\n }\\n\\n /// @inheritdoc Vesting\\n function totalSupply() external view override returns (uint256) {\\n return _getTotalSupply();\\n }\\n\\n function _getVotingUnits(address account) internal view override returns (uint256) {\\n return balanceOf[account];\\n }\\n\\n function _beforeBurn(address from, uint256 amount) internal override {\\n _transferVotingUnits(from, address(0x00), amount);\\n }\\n}\\n\",\"keccak256\":\"0x136ebbc0fc78a2347c6dfd902b6235b204df1663298dc23b75530828b8bc524f\",\"license\":\"Apache-2.0\"}},\"version\":1}", "bytecode": "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", diff --git a/web/src/constants/addresses.js b/web/src/constants/addresses.js index a51925e..1412564 100644 --- a/web/src/constants/addresses.js +++ b/web/src/constants/addresses.js @@ -1,6 +1,6 @@ export const governanceContracts = { sepolia: { token: "0x1e554D8f3Bd07D27ef47DD4571a16CDA74c3b731", - devRewardDistributor: "0x56dCb8dDD86B970a5229c4B0DB8f5B179A9a651D", + devRewardDistributor: "0xFC3D7144d302Bc19B2363Fb28F3061a14255996d", }, };