diff --git a/contracts/.openzeppelin/unknown-314.json b/contracts/.openzeppelin/unknown-314.json new file mode 100644 index 0000000..8d9ce99 --- /dev/null +++ b/contracts/.openzeppelin/unknown-314.json @@ -0,0 +1,378 @@ +{ + "manifestVersion": "3.2", + "proxies": [ + { + "address": "0xc756B203cA9e13BAB3a93F1dA756bb19ac3C395b", + "txHash": "0x156e81e9a16577720188d459968da962fb4c2ac486f41b7fcd35f3da5db1dce4", + "kind": "uups" + } + ], + "impls": { + "125db54394ee349f18c5e7b6f717dff5868c4ccab68a96eeef38a6321b3f05b2": { + "address": "0xC2d179166bc9dbB00A03686a5b17eCe2224c2704", + "txHash": "0x257ba62bb627665fc829d31ba5eaa38bfcc88d053a6dbd6022d1f1a568c4d10b", + "layout": { + "solcVersion": "0.8.17", + "storage": [ + { + "label": "_initialized", + "offset": 0, + "slot": "0", + "type": "t_uint8", + "contract": "Initializable", + "src": "lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol:62", + "retypedFrom": "bool" + }, + { + "label": "_initializing", + "offset": 1, + "slot": "0", + "type": "t_bool", + "contract": "Initializable", + "src": "lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol:67" + }, + { + "label": "__gap", + "offset": 0, + "slot": "1", + "type": "t_array(t_uint256)50_storage", + "contract": "ContextUpgradeable", + "src": "lib/openzeppelin-contracts-upgradeable/contracts/utils/ContextUpgradeable.sol:36" + }, + { + "label": "__gap", + "offset": 0, + "slot": "51", + "type": "t_array(t_uint256)50_storage", + "contract": "ERC165Upgradeable", + "src": "lib/openzeppelin-contracts-upgradeable/contracts/utils/introspection/ERC165Upgradeable.sol:41" + }, + { + "label": "_balances", + "offset": 0, + "slot": "101", + "type": "t_mapping(t_uint256,t_mapping(t_address,t_uint256))", + "contract": "ERC1155Upgradeable", + "src": "lib/openzeppelin-contracts-upgradeable/contracts/token/ERC1155/ERC1155Upgradeable.sol:25" + }, + { + "label": "_operatorApprovals", + "offset": 0, + "slot": "102", + "type": "t_mapping(t_address,t_mapping(t_address,t_bool))", + "contract": "ERC1155Upgradeable", + "src": "lib/openzeppelin-contracts-upgradeable/contracts/token/ERC1155/ERC1155Upgradeable.sol:28" + }, + { + "label": "_uri", + "offset": 0, + "slot": "103", + "type": "t_string_storage", + "contract": "ERC1155Upgradeable", + "src": "lib/openzeppelin-contracts-upgradeable/contracts/token/ERC1155/ERC1155Upgradeable.sol:31" + }, + { + "label": "__gap", + "offset": 0, + "slot": "104", + "type": "t_array(t_uint256)47_storage", + "contract": "ERC1155Upgradeable", + "src": "lib/openzeppelin-contracts-upgradeable/contracts/token/ERC1155/ERC1155Upgradeable.sol:528" + }, + { + "label": "__gap", + "offset": 0, + "slot": "151", + "type": "t_array(t_uint256)50_storage", + "contract": "ERC1155BurnableUpgradeable", + "src": "lib/openzeppelin-contracts-upgradeable/contracts/token/ERC1155/extensions/ERC1155BurnableUpgradeable.sol:52" + }, + { + "label": "_baseURI", + "offset": 0, + "slot": "201", + "type": "t_string_storage", + "contract": "ERC1155URIStorageUpgradeable", + "src": "lib/openzeppelin-contracts-upgradeable/contracts/token/ERC1155/extensions/ERC1155URIStorageUpgradeable.sol:27" + }, + { + "label": "_tokenURIs", + "offset": 0, + "slot": "202", + "type": "t_mapping(t_uint256,t_string_storage)", + "contract": "ERC1155URIStorageUpgradeable", + "src": "lib/openzeppelin-contracts-upgradeable/contracts/token/ERC1155/extensions/ERC1155URIStorageUpgradeable.sol:30" + }, + { + "label": "__gap", + "offset": 0, + "slot": "203", + "type": "t_array(t_uint256)48_storage", + "contract": "ERC1155URIStorageUpgradeable", + "src": "lib/openzeppelin-contracts-upgradeable/contracts/token/ERC1155/extensions/ERC1155URIStorageUpgradeable.sol:77" + }, + { + "label": "_owner", + "offset": 0, + "slot": "251", + "type": "t_address", + "contract": "OwnableUpgradeable", + "src": "lib/openzeppelin-contracts-upgradeable/contracts/access/OwnableUpgradeable.sol:22" + }, + { + "label": "__gap", + "offset": 0, + "slot": "252", + "type": "t_array(t_uint256)49_storage", + "contract": "OwnableUpgradeable", + "src": "lib/openzeppelin-contracts-upgradeable/contracts/access/OwnableUpgradeable.sol:94" + }, + { + "label": "__gap", + "offset": 0, + "slot": "301", + "type": "t_array(t_uint256)50_storage", + "contract": "ERC1967UpgradeUpgradeable", + "src": "lib/openzeppelin-contracts-upgradeable/contracts/proxy/ERC1967/ERC1967UpgradeUpgradeable.sol:211" + }, + { + "label": "__gap", + "offset": 0, + "slot": "351", + "type": "t_array(t_uint256)50_storage", + "contract": "UUPSUpgradeable", + "src": "lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/UUPSUpgradeable.sol:107" + }, + { + "label": "typeCounter", + "offset": 0, + "slot": "401", + "type": "t_uint256", + "contract": "SemiFungible1155", + "src": "src/protocol/SemiFungible1155.sol:27" + }, + { + "label": "owners", + "offset": 0, + "slot": "402", + "type": "t_mapping(t_uint256,t_address)", + "contract": "SemiFungible1155", + "src": "src/protocol/SemiFungible1155.sol:38" + }, + { + "label": "creators", + "offset": 0, + "slot": "403", + "type": "t_mapping(t_uint256,t_address)", + "contract": "SemiFungible1155", + "src": "src/protocol/SemiFungible1155.sol:41" + }, + { + "label": "tokenValues", + "offset": 0, + "slot": "404", + "type": "t_mapping(t_uint256,t_uint256)", + "contract": "SemiFungible1155", + "src": "src/protocol/SemiFungible1155.sol:44" + }, + { + "label": "maxIndex", + "offset": 0, + "slot": "405", + "type": "t_mapping(t_uint256,t_uint256)", + "contract": "SemiFungible1155", + "src": "src/protocol/SemiFungible1155.sol:47" + }, + { + "label": "__gap", + "offset": 0, + "slot": "406", + "type": "t_array(t_uint256)25_storage", + "contract": "SemiFungible1155", + "src": "src/protocol/SemiFungible1155.sol:648" + }, + { + "label": "merkleRoots", + "offset": 0, + "slot": "431", + "type": "t_mapping(t_uint256,t_bytes32)", + "contract": "AllowlistMinter", + "src": "src/protocol/AllowlistMinter.sol:17" + }, + { + "label": "hasBeenClaimed", + "offset": 0, + "slot": "432", + "type": "t_mapping(t_uint256,t_mapping(t_bytes32,t_bool))", + "contract": "AllowlistMinter", + "src": "src/protocol/AllowlistMinter.sol:18" + }, + { + "label": "maxUnits", + "offset": 0, + "slot": "433", + "type": "t_mapping(t_uint256,t_uint256)", + "contract": "AllowlistMinter", + "src": "src/protocol/AllowlistMinter.sol:19" + }, + { + "label": "minted", + "offset": 0, + "slot": "434", + "type": "t_mapping(t_uint256,t_uint256)", + "contract": "AllowlistMinter", + "src": "src/protocol/AllowlistMinter.sol:20" + }, + { + "label": "__gap", + "offset": 0, + "slot": "435", + "type": "t_array(t_uint256)26_storage", + "contract": "AllowlistMinter", + "src": "src/protocol/AllowlistMinter.sol:75" + }, + { + "label": "_paused", + "offset": 0, + "slot": "461", + "type": "t_bool", + "contract": "PausableUpgradeable", + "src": "lib/openzeppelin-contracts-upgradeable/contracts/security/PausableUpgradeable.sol:29" + }, + { + "label": "__gap", + "offset": 0, + "slot": "462", + "type": "t_array(t_uint256)49_storage", + "contract": "PausableUpgradeable", + "src": "lib/openzeppelin-contracts-upgradeable/contracts/security/PausableUpgradeable.sol:116" + }, + { + "label": "typeRestrictions", + "offset": 0, + "slot": "511", + "type": "t_mapping(t_uint256,t_enum(TransferRestrictions)19595)", + "contract": "HypercertMinter", + "src": "src/protocol/HypercertMinter.sol:20" + }, + { + "label": "__gap", + "offset": 0, + "slot": "512", + "type": "t_array(t_uint256)29_storage", + "contract": "HypercertMinter", + "src": "src/protocol/HypercertMinter.sol:258" + } + ], + "types": { + "t_address": { + "label": "address", + "numberOfBytes": "20" + }, + "t_array(t_uint256)25_storage": { + "label": "uint256[25]", + "numberOfBytes": "800" + }, + "t_array(t_uint256)26_storage": { + "label": "uint256[26]", + "numberOfBytes": "832" + }, + "t_array(t_uint256)29_storage": { + "label": "uint256[29]", + "numberOfBytes": "928" + }, + "t_array(t_uint256)47_storage": { + "label": "uint256[47]", + "numberOfBytes": "1504" + }, + "t_array(t_uint256)48_storage": { + "label": "uint256[48]", + "numberOfBytes": "1536" + }, + "t_array(t_uint256)49_storage": { + "label": "uint256[49]", + "numberOfBytes": "1568" + }, + "t_array(t_uint256)50_storage": { + "label": "uint256[50]", + "numberOfBytes": "1600" + }, + "t_bool": { + "label": "bool", + "numberOfBytes": "1" + }, + "t_bytes32": { + "label": "bytes32", + "numberOfBytes": "32" + }, + "t_enum(TransferRestrictions)19595": { + "label": "enum IHypercertToken.TransferRestrictions", + "members": [ + "AllowAll", + "DisallowAll", + "FromCreatorOnly" + ], + "numberOfBytes": "1" + }, + "t_mapping(t_address,t_bool)": { + "label": "mapping(address => bool)", + "numberOfBytes": "32" + }, + "t_mapping(t_address,t_mapping(t_address,t_bool))": { + "label": "mapping(address => mapping(address => bool))", + "numberOfBytes": "32" + }, + "t_mapping(t_address,t_uint256)": { + "label": "mapping(address => uint256)", + "numberOfBytes": "32" + }, + "t_mapping(t_bytes32,t_bool)": { + "label": "mapping(bytes32 => bool)", + "numberOfBytes": "32" + }, + "t_mapping(t_uint256,t_address)": { + "label": "mapping(uint256 => address)", + "numberOfBytes": "32" + }, + "t_mapping(t_uint256,t_bytes32)": { + "label": "mapping(uint256 => bytes32)", + "numberOfBytes": "32" + }, + "t_mapping(t_uint256,t_enum(TransferRestrictions)19595)": { + "label": "mapping(uint256 => enum IHypercertToken.TransferRestrictions)", + "numberOfBytes": "32" + }, + "t_mapping(t_uint256,t_mapping(t_address,t_uint256))": { + "label": "mapping(uint256 => mapping(address => uint256))", + "numberOfBytes": "32" + }, + "t_mapping(t_uint256,t_mapping(t_bytes32,t_bool))": { + "label": "mapping(uint256 => mapping(bytes32 => bool))", + "numberOfBytes": "32" + }, + "t_mapping(t_uint256,t_string_storage)": { + "label": "mapping(uint256 => string)", + "numberOfBytes": "32" + }, + "t_mapping(t_uint256,t_uint256)": { + "label": "mapping(uint256 => uint256)", + "numberOfBytes": "32" + }, + "t_string_storage": { + "label": "string", + "numberOfBytes": "32" + }, + "t_uint256": { + "label": "uint256", + "numberOfBytes": "32" + }, + "t_uint8": { + "label": "uint8", + "numberOfBytes": "1" + } + }, + "namespaces": {} + } + } + } +} diff --git a/contracts/config/ChainConfig.ts b/contracts/config/ChainConfig.ts new file mode 100644 index 0000000..2f5e444 --- /dev/null +++ b/contracts/config/ChainConfig.ts @@ -0,0 +1,271 @@ +import { NetworkUserConfig } from "hardhat/types"; +import { requireEnv } from "../utils/requireEnv"; + +// Chain IDs +export const chainIds = { + hardhat: 31337, + sepolia: 11155111, + "optimism-mainnet": 10, + "celo-mainnet": 42220, + "base-sepolia": 84532, + "base-mainnet": 8453, + "arb-sepolia": 421614, + arbitrumOne: 42161, + filecoinCalibration: 314159, + "filecoin-mainnet": 314, +}; + +interface EtherscanConfig { + apiKey: string; + apiURL?: string; + browserURL?: string; +} + +interface CustomChainConfig { + network: string; + chainId: number; + urls: { + apiURL: string; + browserURL: string; + }; +} + +interface ChainStrategy { + getConfig(): NetworkUserConfig; + getEtherscanConfig?(): EtherscanConfig; + getCustomChainConfig?(): CustomChainConfig; +} + +class DefaultChainStrategy implements ChainStrategy { + constructor(private chain: keyof typeof chainIds, private mnemonic: string) {} + + getConfig(): NetworkUserConfig { + return { + accounts: { + count: 10, + mnemonic: this.mnemonic, + path: "m/44'/60'/0'/0", + }, + chainId: chainIds[this.chain], + url: `https://${this.chain}.infura.io/v3/${requireEnv(process.env.INFURA_API_KEY, "INFURA_API_KEY")}`, + }; + } + + getEtherscanConfig(): EtherscanConfig { + return { + apiKey: requireEnv(process.env.ETHERSCAN_API_KEY, "ETHERSCAN_API_KEY"), + }; + } + + getCustomChainConfig(): CustomChainConfig { + return { + network: this.chain, + chainId: chainIds[this.chain], + urls: { + apiURL: "", + browserURL: "", + }, + }; + } +} + +export class OptimismStrategy extends DefaultChainStrategy { + getConfig(): NetworkUserConfig { + return { + ...super.getConfig(), + url: `https://opt-mainnet.g.alchemy.com/v2/${requireEnv(process.env.ALCHEMY_API_KEY, "ALCHEMY_API_KEY")}`, + }; + } + + getEtherscanConfig(): EtherscanConfig { + return { + apiKey: requireEnv(process.env.OPTIMISTIC_ETHERSCAN_API_KEY, "OPTIMISTIC_ETHERSCAN_API_KEY"), + }; + } +} + +export class BaseSepoliaStrategy extends DefaultChainStrategy { + getConfig(): NetworkUserConfig { + return { + ...super.getConfig(), + url: "https://sepolia.base.org", + gasPrice: 1000000000, + }; + } + + getEtherscanConfig(): EtherscanConfig { + return { + apiKey: requireEnv(process.env.BASESCAN_API_KEY, "BASESCAN_API_KEY"), + apiURL: "https://api-sepolia.basescan.org/api", + browserURL: "https://sepolia.basescan.org", + }; + } + + getCustomChainConfig(): CustomChainConfig { + return { + network: "base-sepolia", + chainId: chainIds["base-sepolia"], + urls: { + apiURL: "https://api-sepolia.basescan.org/api", + browserURL: "https://sepolia.basescan.org", + }, + }; + } +} + +export class BaseMainnetStrategy extends DefaultChainStrategy { + getConfig(): NetworkUserConfig { + return { + ...super.getConfig(), + url: `https://base-mainnet.g.alchemy.com/v2/${requireEnv(process.env.ALCHEMY_API_KEY, "ALCHEMY_API_KEY")}`, + gasPrice: 1000000000, + }; + } + + getEtherscanConfig(): EtherscanConfig { + return { + apiKey: requireEnv(process.env.BASESCAN_API_KEY, "BASESCAN_API_KEY"), + }; + } +} + +export class ArbSepoliaStrategy extends DefaultChainStrategy { + getConfig(): NetworkUserConfig { + return { + ...super.getConfig(), + url: `https://arb-sepolia.g.alchemy.com/v2/${requireEnv(process.env.ALCHEMY_API_KEY, "ALCHEMY_API_KEY")}`, + }; + } + + getEtherscanConfig(): EtherscanConfig { + return { + apiKey: requireEnv(process.env.ARBISCAN_API_KEY, "ARBISCAN_API_KEY"), + apiURL: "https://api-sepolia.arbiscan.io/api", + browserURL: "https://sepolia.arbiscan.io/", + }; + } + + getCustomChainConfig(): CustomChainConfig { + return { + network: "arb-sepolia", + chainId: chainIds["arb-sepolia"], + urls: { + apiURL: "https://api-sepolia.arbiscan.io/api", + browserURL: "https://sepolia.arbiscan.io/", + }, + }; + } +} + +export class ArbitrumStrategy extends DefaultChainStrategy { + getConfig(): NetworkUserConfig { + return { + ...super.getConfig(), + url: `https://arb-mainnet.g.alchemy.com/v2/${requireEnv(process.env.ALCHEMY_API_KEY, "ALCHEMY_API_KEY")}`, + }; + } + + getEtherscanConfig(): EtherscanConfig { + return { + apiKey: "DPB1JAY49URG4RJP76WQ11CMGPBF2FX3C5", + }; + } +} + +export class CeloStrategy extends DefaultChainStrategy { + getConfig(): NetworkUserConfig { + return { + ...super.getConfig(), + accounts: { + count: 10, + mnemonic: requireEnv(process.env.MNEMONIC_CELO, "MNEMONIC_CELO"), + path: "m/44'/52752'/0'/0", + }, + }; + } + + getEtherscanConfig(): EtherscanConfig { + return { + apiKey: requireEnv(process.env.CELOSCAN_API_KEY, "CELOSCAN_API_KEY"), + apiURL: "https://api.celoscan.io/api", + browserURL: "https://celoscan.io/", + }; + } + + getCustomChainConfig(): CustomChainConfig { + return { + network: "celo-mainnet", + chainId: chainIds["celo-mainnet"], + urls: { + apiURL: "https://api.celoscan.io/api", + browserURL: "https://celoscan.io/", + }, + }; + } +} + +export class FilecoinCalibrationStrategy extends DefaultChainStrategy { + getConfig(): NetworkUserConfig { + return { + ...super.getConfig(), + url: "https://filecoin-calibration.chainup.net/rpc/v1", + }; + } +} + +export class FilecoinMainnetStrategy extends DefaultChainStrategy { + getConfig(): NetworkUserConfig { + return { + ...super.getConfig(), + url: "https://filecoin.chainup.net/rpc/v1", + }; + } +} + +// Factory +export function getChainStrategy(chain: keyof typeof chainIds, mnemonic: string): ChainStrategy { + switch (chain) { + case "optimism-mainnet": + return new OptimismStrategy(chain, mnemonic); + case "base-sepolia": + return new BaseSepoliaStrategy(chain, mnemonic); + case "base-mainnet": + return new BaseMainnetStrategy(chain, mnemonic); + case "arb-sepolia": + return new ArbSepoliaStrategy(chain, mnemonic); + case "arbitrumOne": + return new ArbitrumStrategy(chain, mnemonic); + case "celo-mainnet": + return new CeloStrategy(chain, mnemonic); + case "filecoinCalibration": + return new FilecoinCalibrationStrategy(chain, mnemonic); + case "filecoin-mainnet": + return new FilecoinMainnetStrategy(chain, mnemonic); + default: + return new DefaultChainStrategy(chain, mnemonic); + } +} + +// Helper function to get all etherscan configs +export function getEtherscanConfigs(): Record { + const configs: Record = {}; + Object.keys(chainIds).forEach((chain) => { + const strategy = getChainStrategy(chain as keyof typeof chainIds, "dummy"); + if (strategy.getEtherscanConfig) { + configs[chain] = strategy.getEtherscanConfig(); + } + }); + return configs; +} + +// Add helper function to get custom chains +export function getCustomChains(): CustomChainConfig[] { + const customChains: CustomChainConfig[] = []; + Object.keys(chainIds).forEach((chain) => { + const strategy = getChainStrategy(chain as keyof typeof chainIds, "dummy"); + if (strategy.getCustomChainConfig) { + customChains.push(strategy.getCustomChainConfig()); + } + }); + return customChains; +} diff --git a/contracts/hardhat.config.cts b/contracts/hardhat.config.cts index c82b364..2af7602 100644 --- a/contracts/hardhat.config.cts +++ b/contracts/hardhat.config.cts @@ -6,7 +6,6 @@ import "@nomicfoundation/hardhat-viem"; import "@openzeppelin/hardhat-upgrades"; import "@typechain/hardhat"; import "@nomicfoundation/hardhat-ethers"; -import "@starboardventures/hardhat-verify"; import "@primitivefi/hardhat-dodoc"; import { config as dotenvConfig } from "dotenv"; @@ -15,10 +14,9 @@ import "hardhat-abi-exporter"; import "hardhat-preprocessor"; import { resolve } from "path"; -import "xdeployer"; - import "./tasks"; - +import { chainIds, getChainStrategy, getEtherscanConfigs, getCustomChains } from "./config/ChainConfig"; +import { requireEnv } from "./utils/requireEnv"; function getRemappings() { return fs .readFileSync("remappings.txt", "utf8") @@ -27,118 +25,12 @@ function getRemappings() { .map((line) => line.trim().split("=")); } -function requireEnv(value: string | undefined, identifier: string) { - /** - if (!value) { - throw new Error(`Required env var ${identifier} does not exist`); - } - **/ - return value; -} - const dotenvConfigPath: string = process.env.DOTENV_PATH ?? fs.existsSync("./.env") ? "./.env" : "./.env.example"; dotenvConfig({ path: resolve(__dirname, dotenvConfigPath) }); // Ensure that we have all the environment variables we need. const MNEMONIC = requireEnv(process.env.MNEMONIC, "MNEMONIC"); const MNEMONIC_CELO = requireEnv(process.env.MNEMONIC_CELO, "MNEMONIC_CELO"); -const INFURA_API_KEY = requireEnv(process.env.INFURA_API_KEY, "INFURA_API_KEY"); -const ALCHEMY_API_KEY = requireEnv(process.env.ALCHEMY_API_KEY, "ALCHEMY_API_KEY"); - -const ETHERSCAN_API_KEY = requireEnv(process.env.ETHERSCAN_API_KEY, "ETHERSCAN_API_KEY"); -const OPTIMISTIC_ETHERSCAN_API_KEY = requireEnv( - process.env.OPTIMISTIC_ETHERSCAN_API_KEY, - "OPTIMISTIC_ETHERSCAN_API_KEY", -); -const CELOSCAN_API_KEY = requireEnv(process.env.CELOSCAN_API_KEY, "CELOSCAN_API_KEY"); -const BASESCAN_API_KEY = requireEnv(process.env.BASESCAN_API_KEY, "BASESCAN_API_KEY"); -const ARBISCAN_API_KEY = requireEnv(process.env.ARBISCAN_API_KEY, "ARBISCAN_API_KEY"); - -/** - * Maps a key to the chain ID - * - Make sure the key matches the Infura subdomain - */ -const chainIds = { - hardhat: 31337, - sepolia: 11155111, - "optimism-mainnet": 10, - "celo-mainnet": 42220, - "base-sepolia": 84532, - "base-mainnet": 8453, - "arb-sepolia": 421614, - arbitrumOne: 42161, - "filecoinCalibration": 314159, -}; - -function getChainConfig(chain: keyof typeof chainIds) { - const jsonRpcUrl = "https://" + chain + ".infura.io/v3/" + INFURA_API_KEY; - let config: { [key: string]: string | number | { [key: string]: string | number } } = { - accounts: { - count: 10, - mnemonic: MNEMONIC!, - path: "m/44'/60'/0'/0", - }, - chainId: chainIds[chain], - url: jsonRpcUrl, - }; - - if (chain === "optimism-mainnet") { - config = { - ...config, - url: `https://opt-mainnet.g.alchemy.com/v2/${ALCHEMY_API_KEY}`, - }; - } - - if (chain === "base-sepolia") { - config = { - ...config, - url: `https://sepolia.base.org`, - gasPrice: 1000000000, - }; - } - - if (chain === "base-mainnet") { - config = { - ...config, - url: `https://base-mainnet.g.alchemy.com/v2/${ALCHEMY_API_KEY}`, - gasPrice: 1000000000, - }; - } - - if (chain === "arb-sepolia") { - config = { - ...config, - url: `https://arb-sepolia.g.alchemy.com/v2/${ALCHEMY_API_KEY}`, - }; - } - - if (chain === "arbitrumOne") { - config = { - ...config, - url: `https://arb-mainnet.g.alchemy.com/v2/${ALCHEMY_API_KEY}`, - }; - } - - if (chain === "celo-mainnet") { - config = { - ...config, - accounts: { - count: 10, - mnemonic: MNEMONIC_CELO, - path: "m/44'/52752'/0'/0", - }, - }; - } - - if (chain === "filecoinCalibration") { - config = { - ...config, - url: `https://filecoin-calibration.chainup.net/rpc/v1`, - }; - } - - return config; -} const config: HardhatUserConfig = { abiExporter: { @@ -169,46 +61,11 @@ const config: HardhatUserConfig = { outputDir: "../docs/docs/developer/api/contracts", }, etherscan: { - apiKey: { - sepolia: ETHERSCAN_API_KEY!, - optimisticEthereum: OPTIMISTIC_ETHERSCAN_API_KEY!, - "celo-mainnet": CELOSCAN_API_KEY!, - base: BASESCAN_API_KEY!, - "base-sepolia": BASESCAN_API_KEY!, - "arb-sepolia": ARBISCAN_API_KEY!, - arbitrumOne: "DPB1JAY49URG4RJP76WQ11CMGPBF2FX3C5", - }, - customChains: [ - { - network: "celo-mainnet", - chainId: 42220, - urls: { - apiURL: "https://api.celoscan.io/api", - browserURL: "https://celoscan.io/", - }, - }, - { - network: "base-sepolia", - chainId: 84532, - urls: { - apiURL: "https://api-sepolia.basescan.org/api", - browserURL: "https://sepolia.basescan.org", - }, - }, - { - network: "arb-sepolia", - chainId: 421614, - urls: { - apiURL: "https://api-sepolia.arbiscan.io/api", - browserURL: "https://sepolia.arbiscan.io/", - }, - }, - ], + apiKey: getEtherscanConfigs(), + customChains: getCustomChains(), }, networks: { hardhat: { - // Setting this is necessary for metamask to work with hardhat. Otherwise - // metamask can't transfer when connected to hardhat's network. initialBaseFeePerGas: 0, accounts: { count: 10, @@ -224,14 +81,15 @@ const config: HardhatUserConfig = { path: "m/44'/60'/0'/0", }, }, - "celo-mainnet": getChainConfig("celo-mainnet"), - sepolia: getChainConfig("sepolia"), - "optimism-mainnet": getChainConfig("optimism-mainnet"), - "base-sepolia": getChainConfig("base-sepolia"), - "base-mainnet": getChainConfig("base-mainnet"), - "arb-sepolia": getChainConfig("arb-sepolia"), - arbitrumOne: getChainConfig("arbitrumOne"), - filecoinCalibration: getChainConfig("filecoinCalibration"), + "celo-mainnet": getChainStrategy("celo-mainnet", MNEMONIC_CELO).getConfig(), + sepolia: getChainStrategy("sepolia", MNEMONIC).getConfig(), + "optimism-mainnet": getChainStrategy("optimism-mainnet", MNEMONIC).getConfig(), + "base-sepolia": getChainStrategy("base-sepolia", MNEMONIC).getConfig(), + "base-mainnet": getChainStrategy("base-mainnet", MNEMONIC).getConfig(), + "arb-sepolia": getChainStrategy("arb-sepolia", MNEMONIC).getConfig(), + arbitrumOne: getChainStrategy("arbitrumOne", MNEMONIC).getConfig(), + filecoinCalibration: getChainStrategy("filecoinCalibration", MNEMONIC).getConfig(), + "filecoin-mainnet": getChainStrategy("filecoin-mainnet", MNEMONIC).getConfig(), }, paths: { cache: "./cache_hardhat", // Use a different cache for Hardhat than Foundry @@ -265,10 +123,6 @@ const config: HardhatUserConfig = { }, }, }, - starboardConfig: { - baseURL: "https://fvm-calibration-api.starboard.ventures", - network: "Calibration", // if there's no baseURL, url will depend on the network. Mainnet || Calibration - }, typechain: { outDir: "./types", }, diff --git a/contracts/package.json b/contracts/package.json index 527599b..1ea266e 100644 --- a/contracts/package.json +++ b/contracts/package.json @@ -1,7 +1,7 @@ { "name": "@hypercerts-org/contracts", "description": "EVM compatible protocol for managing impact claims", - "version": "2.0.0-alpha.11", + "version": "2.0.0-alpha.12", "author": { "name": "Hypercerts Foundation", "url": "https://github.com/hypercerts-org/hypercerts" @@ -40,43 +40,42 @@ "@openzeppelin/hardhat-upgrades": "3.9.0", "@primitivefi/hardhat-dodoc": "^0.2.3", "@rollup/plugin-commonjs": "^24.0.1", - "@rollup/plugin-json": "^6.0.0", - "@rollup/plugin-node-resolve": "^15.0.1", + "@rollup/plugin-json": "^6.1.0", + "@rollup/plugin-node-resolve": "^15.3.1", "@trivago/prettier-plugin-sort-imports": "^3.3.0", "@typechain/hardhat": "^9.1.0", - "@types/node": "^18.18.1", - "@typescript-eslint/eslint-plugin": "^7.12.0", - "@typescript-eslint/parser": "^7.12.0", + "@types/node": "^18.19.71", + "@typescript-eslint/eslint-plugin": "^7.18.0", + "@typescript-eslint/parser": "^7.18.0", "chai": "^4.5.0", - "commitizen": "^4.2.5", + "commitizen": "^4.3.1", "cross-env": "^7.0.3", "cz-conventional-changelog": "^3.3.0", - "dotenv": "^16.0.2", - "eslint": "^8.23.1", + "dotenv": "^16.4.7", + "eslint": "^8.57.1", "eslint-config-prettier": "^8.5.0", - "ethers": "^6.8.0", + "ethers": "^6.13.5", "hardhat-abi-exporter": "^2.10.1", "hardhat-preprocessor": "^0.1.5", "husky": "^8.0.1", "lint-staged": "^13.0.3", "prettier": "^2.8.8", - "prettier-plugin-solidity": "^1.1.3", - "rimraf": "^5.0.5", - "rollup": "^4.0.2", + "prettier-plugin-solidity": "^1.4.2", + "rimraf": "^5.0.10", + "rollup": "^4.31.0", "rollup-plugin-auto-external": "^2.0.0", "rollup-plugin-dts": "^6.1.1", - "rollup-plugin-esbuild": "^6.1.0", + "rollup-plugin-esbuild": "^6.1.1", "rollup-plugin-node-polyfills": "^0.2.1", "rollup-plugin-swc3": "^0.11.2", "shx": "^0.3.4", "solhint": "^3.6.2", "solhint-plugin-prettier": "^0.0.5", - "solmate": "^6.2.0", - "ts-node": "^10.9.1", + "solmate": "^6.8.0", + "ts-node": "^10.9.2", "typechain": "^8.3.2", - "typescript": "^5.5.3", - "viem": "^2.19.7", - "xdeployer": "^2.1.13" + "typescript": "^5.7.3", + "viem": "^2.22.10" }, "keywords": [ "blockchain", @@ -112,8 +111,6 @@ "hardhat": "hardhat" }, "dependencies": { - "@starboardventures/hardhat-verify": "^1.0.1", - "@tenderly/hardhat-tenderly": "^2.3.0", "hardhat": "^2.22.18" } } diff --git a/contracts/resources/FlattenedHypercertMinter.sol b/contracts/resources/FlattenedHypercertMinter.sol new file mode 100644 index 0000000..ba372bc --- /dev/null +++ b/contracts/resources/FlattenedHypercertMinter.sol @@ -0,0 +1,3678 @@ +// Sources flattened with hardhat v2.22.18 https://hardhat.org + +// SPDX-License-Identifier: MIT + +// File lib/openzeppelin-contracts-upgradeable/contracts/utils/AddressUpgradeable.sol + +// Original license: SPDX_License_Identifier: MIT +// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol) + +pragma solidity ^0.8.1; + +/** + * @dev Collection of functions related to the address type + */ +library AddressUpgradeable { + /** + * @dev Returns true if `account` is a contract. + * + * [IMPORTANT] + * ==== + * It is unsafe to assume that an address for which this function returns + * false is an externally-owned account (EOA) and not a contract. + * + * Among others, `isContract` will return false for the following + * types of addresses: + * + * - an externally-owned account + * - a contract in construction + * - an address where a contract will be created + * - an address where a contract lived, but was destroyed + * ==== + * + * [IMPORTANT] + * ==== + * You shouldn't rely on `isContract` to protect against flash loan attacks! + * + * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets + * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract + * constructor. + * ==== + */ + function isContract(address account) internal view returns (bool) { + // This method relies on extcodesize/address.code.length, which returns 0 + // for contracts in construction, since the code is only stored at the end + // of the constructor execution. + + return account.code.length > 0; + } + + /** + * @dev Replacement for Solidity's `transfer`: sends `amount` wei to + * `recipient`, forwarding all available gas and reverting on errors. + * + * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost + * of certain opcodes, possibly making contracts go over the 2300 gas limit + * imposed by `transfer`, making them unable to receive funds via + * `transfer`. {sendValue} removes this limitation. + * + * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more]. + * + * IMPORTANT: because control is transferred to `recipient`, care must be + * taken to not create reentrancy vulnerabilities. Consider using + * {ReentrancyGuard} or the + * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions + * pattern]. + */ + function sendValue(address payable recipient, uint256 amount) internal { + require(address(this).balance >= amount, "Address: insufficient balance"); + + (bool success,) = recipient.call{value: amount}(""); + require(success, "Address: unable to send value, recipient may have reverted"); + } + + /** + * @dev Performs a Solidity function call using a low level `call`. A + * plain `call` is an unsafe replacement for a function call: use this + * function instead. + * + * If `target` reverts with a revert reason, it is bubbled up by this + * function (like regular Solidity function calls). + * + * Returns the raw returned data. To convert to the expected return value, + * use + * https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. + * + * Requirements: + * + * - `target` must be a contract. + * - calling `target` with `data` must not revert. + * + * _Available since v3.1._ + */ + function functionCall(address target, bytes memory data) internal returns (bytes memory) { + return functionCallWithValue(target, data, 0, "Address: low-level call failed"); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with + * `errorMessage` as a fallback revert reason when `target` reverts. + * + * _Available since v3.1._ + */ + function functionCall(address target, bytes memory data, string memory errorMessage) + internal + returns (bytes memory) + { + return functionCallWithValue(target, data, 0, errorMessage); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], + * but also transferring `value` wei to `target`. + * + * Requirements: + * + * - the calling contract must have an ETH balance of at least `value`. + * - the called Solidity function must be `payable`. + * + * _Available since v3.1._ + */ + function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { + return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); + } + + /** + * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but + * with `errorMessage` as a fallback revert reason when `target` reverts. + * + * _Available since v3.1._ + */ + function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) + internal + returns (bytes memory) + { + require(address(this).balance >= value, "Address: insufficient balance for call"); + (bool success, bytes memory returndata) = target.call{value: value}(data); + return verifyCallResultFromTarget(target, success, returndata, errorMessage); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], + * but performing a static call. + * + * _Available since v3.3._ + */ + function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { + return functionStaticCall(target, data, "Address: low-level static call failed"); + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], + * but performing a static call. + * + * _Available since v3.3._ + */ + function functionStaticCall(address target, bytes memory data, string memory errorMessage) + internal + view + returns (bytes memory) + { + (bool success, bytes memory returndata) = target.staticcall(data); + return verifyCallResultFromTarget(target, success, returndata, errorMessage); + } + + /** + * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling + * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. + * + * _Available since v4.8._ + */ + function verifyCallResultFromTarget( + address target, + bool success, + bytes memory returndata, + string memory errorMessage + ) internal view returns (bytes memory) { + if (success) { + if (returndata.length == 0) { + // only check isContract if the call was successful and the return data is empty + // otherwise we already know that it was a contract + require(isContract(target), "Address: call to non-contract"); + } + return returndata; + } else { + _revert(returndata, errorMessage); + } + } + + /** + * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the + * revert reason or using the provided one. + * + * _Available since v4.3._ + */ + function verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) + internal + pure + returns (bytes memory) + { + if (success) { + return returndata; + } else { + _revert(returndata, errorMessage); + } + } + + function _revert(bytes memory returndata, string memory errorMessage) private pure { + // Look for revert reason and bubble it up if present + if (returndata.length > 0) { + // The easiest way to bubble the revert reason is using memory via assembly + /// @solidity memory-safe-assembly + assembly { + let returndata_size := mload(returndata) + revert(add(32, returndata), returndata_size) + } + } else { + revert(errorMessage); + } + } +} + +// File lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol + +// Original license: SPDX_License_Identifier: MIT +// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol) + +pragma solidity ^0.8.2; + +/** + * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed + * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an + * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer + * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect. + * + * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be + * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in + * case an upgrade adds a module that needs to be initialized. + * + * For example: + * + * [.hljs-theme-light.nopadding] + * ``` + * contract MyToken is ERC20Upgradeable { + * function initialize() initializer public { + * __ERC20_init("MyToken", "MTK"); + * } + * } + * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable { + * function initializeV2() reinitializer(2) public { + * __ERC20Permit_init("MyToken"); + * } + * } + * ``` + * + * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as + * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}. + * + * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure + * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity. + * + * [CAUTION] + * ==== + * Avoid leaving a contract uninitialized. + * + * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation + * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke + * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed: + * + * [.hljs-theme-light.nopadding] + * ``` + * /// @custom:oz-upgrades-unsafe-allow constructor + * constructor() { + * _disableInitializers(); + * } + * ``` + * ==== + */ +abstract contract Initializable { + /** + * @dev Indicates that the contract has been initialized. + * @custom:oz-retyped-from bool + */ + uint8 private _initialized; + + /** + * @dev Indicates that the contract is in the process of being initialized. + */ + bool private _initializing; + + /** + * @dev Triggered when the contract has been initialized or reinitialized. + */ + event Initialized(uint8 version); + + /** + * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope, + * `onlyInitializing` functions can be used to initialize parent contracts. + * + * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a + * constructor. + * + * Emits an {Initialized} event. + */ + modifier initializer() { + bool isTopLevelCall = !_initializing; + require( + (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1), + "Initializable: contract is already initialized" + ); + _initialized = 1; + if (isTopLevelCall) { + _initializing = true; + } + _; + if (isTopLevelCall) { + _initializing = false; + emit Initialized(1); + } + } + + /** + * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the + * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be + * used to initialize parent contracts. + * + * A reinitializer may be used after the original initialization step. This is essential to configure modules that + * are added through upgrades and that require initialization. + * + * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer` + * cannot be nested. If one is invoked in the context of another, execution will revert. + * + * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in + * a contract, executing them in the right order is up to the developer or operator. + * + * WARNING: setting the version to 255 will prevent any future reinitialization. + * + * Emits an {Initialized} event. + */ + modifier reinitializer(uint8 version) { + require(!_initializing && _initialized < version, "Initializable: contract is already initialized"); + _initialized = version; + _initializing = true; + _; + _initializing = false; + emit Initialized(version); + } + + /** + * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the + * {initializer} and {reinitializer} modifiers, directly or indirectly. + */ + modifier onlyInitializing() { + require(_initializing, "Initializable: contract is not initializing"); + _; + } + + /** + * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call. + * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized + * to any version. It is recommended to use this to lock implementation contracts that are designed to be called + * through proxies. + * + * Emits an {Initialized} event the first time it is successfully executed. + */ + function _disableInitializers() internal virtual { + require(!_initializing, "Initializable: contract is initializing"); + if (_initialized != type(uint8).max) { + _initialized = type(uint8).max; + emit Initialized(type(uint8).max); + } + } + + /** + * @dev Internal function that returns the initialized version. Returns `_initialized` + */ + function _getInitializedVersion() internal view returns (uint8) { + return _initialized; + } + + /** + * @dev Internal function that returns the initialized version. Returns `_initializing` + */ + function _isInitializing() internal view returns (bool) { + return _initializing; + } +} + +// File lib/openzeppelin-contracts-upgradeable/contracts/utils/ContextUpgradeable.sol + +// Original license: SPDX_License_Identifier: MIT +// OpenZeppelin Contracts v4.4.1 (utils/Context.sol) + +pragma solidity ^0.8.0; + +/** + * @dev Provides information about the current execution context, including the + * sender of the transaction and its data. While these are generally available + * via msg.sender and msg.data, they should not be accessed in such a direct + * manner, since when dealing with meta-transactions the account sending and + * paying for execution may not be the actual sender (as far as an application + * is concerned). + * + * This contract is only required for intermediate, library-like contracts. + */ +abstract contract ContextUpgradeable is Initializable { + function __Context_init() internal onlyInitializing {} + + function __Context_init_unchained() internal onlyInitializing {} + + function _msgSender() internal view virtual returns (address) { + return msg.sender; + } + + function _msgData() internal view virtual returns (bytes calldata) { + return msg.data; + } + + /** + * @dev This empty reserved space is put in place to allow future versions to add new + * variables without shifting down storage in the inheritance chain. + * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps + */ + uint256[50] private __gap; +} + +// File lib/openzeppelin-contracts-upgradeable/contracts/access/OwnableUpgradeable.sol + +// Original license: SPDX_License_Identifier: MIT +// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) + +pragma solidity ^0.8.0; + +/** + * @dev Contract module which provides a basic access control mechanism, where + * there is an account (an owner) that can be granted exclusive access to + * specific functions. + * + * By default, the owner account will be the one that deploys the contract. This + * can later be changed with {transferOwnership}. + * + * This module is used through inheritance. It will make available the modifier + * `onlyOwner`, which can be applied to your functions to restrict their use to + * the owner. + */ +abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable { + address private _owner; + + event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); + + /** + * @dev Initializes the contract setting the deployer as the initial owner. + */ + function __Ownable_init() internal onlyInitializing { + __Ownable_init_unchained(); + } + + function __Ownable_init_unchained() internal onlyInitializing { + _transferOwnership(_msgSender()); + } + + /** + * @dev Throws if called by any account other than the owner. + */ + modifier onlyOwner() { + _checkOwner(); + _; + } + + /** + * @dev Returns the address of the current owner. + */ + function owner() public view virtual returns (address) { + return _owner; + } + + /** + * @dev Throws if the sender is not the owner. + */ + function _checkOwner() internal view virtual { + require(owner() == _msgSender(), "Ownable: caller is not the owner"); + } + + /** + * @dev Leaves the contract without owner. It will not be possible to call + * `onlyOwner` functions anymore. Can only be called by the current owner. + * + * NOTE: Renouncing ownership will leave the contract without an owner, + * thereby removing any functionality that is only available to the owner. + */ + function renounceOwnership() public virtual onlyOwner { + _transferOwnership(address(0)); + } + + /** + * @dev Transfers ownership of the contract to a new account (`newOwner`). + * Can only be called by the current owner. + */ + function transferOwnership(address newOwner) public virtual onlyOwner { + require(newOwner != address(0), "Ownable: new owner is the zero address"); + _transferOwnership(newOwner); + } + + /** + * @dev Transfers ownership of the contract to a new account (`newOwner`). + * Internal function without access restriction. + */ + function _transferOwnership(address newOwner) internal virtual { + address oldOwner = _owner; + _owner = newOwner; + emit OwnershipTransferred(oldOwner, newOwner); + } + + /** + * @dev This empty reserved space is put in place to allow future versions to add new + * variables without shifting down storage in the inheritance chain. + * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps + */ + uint256[49] private __gap; +} + +// File lib/openzeppelin-contracts-upgradeable/contracts/interfaces/draft-IERC1822Upgradeable.sol + +// Original license: SPDX_License_Identifier: MIT +// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol) + +pragma solidity ^0.8.0; + +/** + * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified + * proxy whose upgrades are fully controlled by the current implementation. + */ +interface IERC1822ProxiableUpgradeable { + /** + * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation + * address. + * + * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks + * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this + * function revert if invoked through a proxy. + */ + function proxiableUUID() external view returns (bytes32); +} + +// File lib/openzeppelin-contracts-upgradeable/contracts/proxy/beacon/IBeaconUpgradeable.sol + +// Original license: SPDX_License_Identifier: MIT +// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol) + +pragma solidity ^0.8.0; + +/** + * @dev This is the interface that {BeaconProxy} expects of its beacon. + */ +interface IBeaconUpgradeable { + /** + * @dev Must return an address that can be used as a delegate call target. + * + * {BeaconProxy} will check that this address is a contract. + */ + function implementation() external view returns (address); +} + +// File lib/openzeppelin-contracts-upgradeable/contracts/utils/StorageSlotUpgradeable.sol + +// Original license: SPDX_License_Identifier: MIT +// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol) + +pragma solidity ^0.8.0; + +/** + * @dev Library for reading and writing primitive types to specific storage slots. + * + * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts. + * This library helps with reading and writing to such slots without the need for inline assembly. + * + * The functions in this library return Slot structs that contain a `value` member that can be used to read or write. + * + * Example usage to set ERC1967 implementation slot: + * ``` + * contract ERC1967 { + * bytes32 internal constant _IMPLEMENTATION_SLOT = + * 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; + * + * function _getImplementation() internal view returns (address) { + * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value; + * } + * + * function _setImplementation(address newImplementation) internal { + * require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract"); + * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; + * } + * } + * ``` + * + * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._ + */ +library StorageSlotUpgradeable { + struct AddressSlot { + address value; + } + + struct BooleanSlot { + bool value; + } + + struct Bytes32Slot { + bytes32 value; + } + + struct Uint256Slot { + uint256 value; + } + + /** + * @dev Returns an `AddressSlot` with member `value` located at `slot`. + */ + function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) { + /// @solidity memory-safe-assembly + assembly { + r.slot := slot + } + } + + /** + * @dev Returns an `BooleanSlot` with member `value` located at `slot`. + */ + function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) { + /// @solidity memory-safe-assembly + assembly { + r.slot := slot + } + } + + /** + * @dev Returns an `Bytes32Slot` with member `value` located at `slot`. + */ + function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) { + /// @solidity memory-safe-assembly + assembly { + r.slot := slot + } + } + + /** + * @dev Returns an `Uint256Slot` with member `value` located at `slot`. + */ + function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) { + /// @solidity memory-safe-assembly + assembly { + r.slot := slot + } + } +} + +// File lib/openzeppelin-contracts-upgradeable/contracts/proxy/ERC1967/ERC1967UpgradeUpgradeable.sol + +// Original license: SPDX_License_Identifier: MIT +// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol) + +pragma solidity ^0.8.2; + +/** + * @dev This abstract contract provides getters and event emitting update functions for + * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots. + * + * _Available since v4.1._ + * + * @custom:oz-upgrades-unsafe-allow delegatecall + */ +abstract contract ERC1967UpgradeUpgradeable is Initializable { + function __ERC1967Upgrade_init() internal onlyInitializing {} + + function __ERC1967Upgrade_init_unchained() internal onlyInitializing {} + // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1 + + bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143; + + /** + * @dev Storage slot with the address of the current implementation. + * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is + * validated in the constructor. + */ + bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; + + /** + * @dev Emitted when the implementation is upgraded. + */ + event Upgraded(address indexed implementation); + + /** + * @dev Returns the current implementation address. + */ + function _getImplementation() internal view returns (address) { + return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value; + } + + /** + * @dev Stores a new address in the EIP1967 implementation slot. + */ + function _setImplementation(address newImplementation) private { + require(AddressUpgradeable.isContract(newImplementation), "ERC1967: new implementation is not a contract"); + StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; + } + + /** + * @dev Perform implementation upgrade + * + * Emits an {Upgraded} event. + */ + function _upgradeTo(address newImplementation) internal { + _setImplementation(newImplementation); + emit Upgraded(newImplementation); + } + + /** + * @dev Perform implementation upgrade with additional setup call. + * + * Emits an {Upgraded} event. + */ + function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal { + _upgradeTo(newImplementation); + if (data.length > 0 || forceCall) { + _functionDelegateCall(newImplementation, data); + } + } + + /** + * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call. + * + * Emits an {Upgraded} event. + */ + function _upgradeToAndCallUUPS(address newImplementation, bytes memory data, bool forceCall) internal { + // Upgrades from old implementations will perform a rollback test. This test requires the new + // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing + // this special case will break upgrade paths from old UUPS implementation to new ones. + if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) { + _setImplementation(newImplementation); + } else { + try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) { + require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID"); + } catch { + revert("ERC1967Upgrade: new implementation is not UUPS"); + } + _upgradeToAndCall(newImplementation, data, forceCall); + } + } + + /** + * @dev Storage slot with the admin of the contract. + * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is + * validated in the constructor. + */ + bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103; + + /** + * @dev Emitted when the admin account has changed. + */ + event AdminChanged(address previousAdmin, address newAdmin); + + /** + * @dev Returns the current admin. + */ + function _getAdmin() internal view returns (address) { + return StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value; + } + + /** + * @dev Stores a new address in the EIP1967 admin slot. + */ + function _setAdmin(address newAdmin) private { + require(newAdmin != address(0), "ERC1967: new admin is the zero address"); + StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value = newAdmin; + } + + /** + * @dev Changes the admin of the proxy. + * + * Emits an {AdminChanged} event. + */ + function _changeAdmin(address newAdmin) internal { + emit AdminChanged(_getAdmin(), newAdmin); + _setAdmin(newAdmin); + } + + /** + * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy. + * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor. + */ + bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50; + + /** + * @dev Emitted when the beacon is upgraded. + */ + event BeaconUpgraded(address indexed beacon); + + /** + * @dev Returns the current beacon. + */ + function _getBeacon() internal view returns (address) { + return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value; + } + + /** + * @dev Stores a new beacon in the EIP1967 beacon slot. + */ + function _setBeacon(address newBeacon) private { + require(AddressUpgradeable.isContract(newBeacon), "ERC1967: new beacon is not a contract"); + require( + AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()), + "ERC1967: beacon implementation is not a contract" + ); + StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon; + } + + /** + * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does + * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that). + * + * Emits a {BeaconUpgraded} event. + */ + function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal { + _setBeacon(newBeacon); + emit BeaconUpgraded(newBeacon); + if (data.length > 0 || forceCall) { + _functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data); + } + } + + /** + * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], + * but performing a delegate call. + * + * _Available since v3.4._ + */ + function _functionDelegateCall(address target, bytes memory data) private returns (bytes memory) { + require(AddressUpgradeable.isContract(target), "Address: delegate call to non-contract"); + + // solhint-disable-next-line avoid-low-level-calls + (bool success, bytes memory returndata) = target.delegatecall(data); + return AddressUpgradeable.verifyCallResult(success, returndata, "Address: low-level delegate call failed"); + } + + /** + * @dev This empty reserved space is put in place to allow future versions to add new + * variables without shifting down storage in the inheritance chain. + * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps + */ + uint256[50] private __gap; +} + +// File lib/openzeppelin-contracts-upgradeable/contracts/proxy/utils/UUPSUpgradeable.sol + +// Original license: SPDX_License_Identifier: MIT +// OpenZeppelin Contracts (last updated v4.5.0) (proxy/utils/UUPSUpgradeable.sol) + +pragma solidity ^0.8.0; + +/** + * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an + * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy. + * + * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is + * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing + * `UUPSUpgradeable` with a custom implementation of upgrades. + * + * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism. + * + * _Available since v4.1._ + */ +abstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable { + function __UUPSUpgradeable_init() internal onlyInitializing {} + + function __UUPSUpgradeable_init_unchained() internal onlyInitializing {} + /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment + + address private immutable __self = address(this); + + /** + * @dev Check that the execution is being performed through a delegatecall call and that the execution context is + * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case + * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a + * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to + * fail. + */ + modifier onlyProxy() { + require(address(this) != __self, "Function must be called through delegatecall"); + require(_getImplementation() == __self, "Function must be called through active proxy"); + _; + } + + /** + * @dev Check that the execution is not being performed through a delegate call. This allows a function to be + * callable on the implementing contract but not through proxies. + */ + modifier notDelegated() { + require(address(this) == __self, "UUPSUpgradeable: must not be called through delegatecall"); + _; + } + + /** + * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the + * implementation. It is used to validate the implementation's compatibility when performing an upgrade. + * + * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks + * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this + * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier. + */ + function proxiableUUID() external view virtual override notDelegated returns (bytes32) { + return _IMPLEMENTATION_SLOT; + } + + /** + * @dev Upgrade the implementation of the proxy to `newImplementation`. + * + * Calls {_authorizeUpgrade}. + * + * Emits an {Upgraded} event. + */ + function upgradeTo(address newImplementation) external virtual onlyProxy { + _authorizeUpgrade(newImplementation); + _upgradeToAndCallUUPS(newImplementation, new bytes(0), false); + } + + /** + * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call + * encoded in `data`. + * + * Calls {_authorizeUpgrade}. + * + * Emits an {Upgraded} event. + */ + function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual onlyProxy { + _authorizeUpgrade(newImplementation); + _upgradeToAndCallUUPS(newImplementation, data, true); + } + + /** + * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by + * {upgradeTo} and {upgradeToAndCall}. + * + * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}. + * + * ```solidity + * function _authorizeUpgrade(address) internal override onlyOwner {} + * ``` + */ + function _authorizeUpgrade(address newImplementation) internal virtual; + + /** + * @dev This empty reserved space is put in place to allow future versions to add new + * variables without shifting down storage in the inheritance chain. + * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps + */ + uint256[50] private __gap; +} + +// File lib/openzeppelin-contracts-upgradeable/contracts/security/PausableUpgradeable.sol + +// Original license: SPDX_License_Identifier: MIT +// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol) + +pragma solidity ^0.8.0; + +/** + * @dev Contract module which allows children to implement an emergency stop + * mechanism that can be triggered by an authorized account. + * + * This module is used through inheritance. It will make available the + * modifiers `whenNotPaused` and `whenPaused`, which can be applied to + * the functions of your contract. Note that they will not be pausable by + * simply including this module, only once the modifiers are put in place. + */ +abstract contract PausableUpgradeable is Initializable, ContextUpgradeable { + /** + * @dev Emitted when the pause is triggered by `account`. + */ + event Paused(address account); + + /** + * @dev Emitted when the pause is lifted by `account`. + */ + event Unpaused(address account); + + bool private _paused; + + /** + * @dev Initializes the contract in unpaused state. + */ + function __Pausable_init() internal onlyInitializing { + __Pausable_init_unchained(); + } + + function __Pausable_init_unchained() internal onlyInitializing { + _paused = false; + } + + /** + * @dev Modifier to make a function callable only when the contract is not paused. + * + * Requirements: + * + * - The contract must not be paused. + */ + modifier whenNotPaused() { + _requireNotPaused(); + _; + } + + /** + * @dev Modifier to make a function callable only when the contract is paused. + * + * Requirements: + * + * - The contract must be paused. + */ + modifier whenPaused() { + _requirePaused(); + _; + } + + /** + * @dev Returns true if the contract is paused, and false otherwise. + */ + function paused() public view virtual returns (bool) { + return _paused; + } + + /** + * @dev Throws if the contract is paused. + */ + function _requireNotPaused() internal view virtual { + require(!paused(), "Pausable: paused"); + } + + /** + * @dev Throws if the contract is not paused. + */ + function _requirePaused() internal view virtual { + require(paused(), "Pausable: not paused"); + } + + /** + * @dev Triggers stopped state. + * + * Requirements: + * + * - The contract must not be paused. + */ + function _pause() internal virtual whenNotPaused { + _paused = true; + emit Paused(_msgSender()); + } + + /** + * @dev Returns to normal state. + * + * Requirements: + * + * - The contract must be paused. + */ + function _unpause() internal virtual whenPaused { + _paused = false; + emit Unpaused(_msgSender()); + } + + /** + * @dev This empty reserved space is put in place to allow future versions to add new + * variables without shifting down storage in the inheritance chain. + * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps + */ + uint256[49] private __gap; +} + +// File lib/openzeppelin-contracts-upgradeable/contracts/utils/introspection/IERC165Upgradeable.sol + +// Original license: SPDX_License_Identifier: MIT +// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) + +pragma solidity ^0.8.0; + +/** + * @dev Interface of the ERC165 standard, as defined in the + * https://eips.ethereum.org/EIPS/eip-165[EIP]. + * + * Implementers can declare support of contract interfaces, which can then be + * queried by others ({ERC165Checker}). + * + * For an implementation, see {ERC165}. + */ +interface IERC165Upgradeable { + /** + * @dev Returns true if this contract implements the interface defined by + * `interfaceId`. See the corresponding + * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] + * to learn more about how these ids are created. + * + * This function call must use less than 30 000 gas. + */ + function supportsInterface(bytes4 interfaceId) external view returns (bool); +} + +// File lib/openzeppelin-contracts-upgradeable/contracts/token/ERC1155/IERC1155Upgradeable.sol + +// Original license: SPDX_License_Identifier: MIT +// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/IERC1155.sol) + +pragma solidity ^0.8.0; + +/** + * @dev Required interface of an ERC1155 compliant contract, as defined in the + * https://eips.ethereum.org/EIPS/eip-1155[EIP]. + * + * _Available since v3.1._ + */ +interface IERC1155Upgradeable is IERC165Upgradeable { + /** + * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`. + */ + event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value); + + /** + * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all + * transfers. + */ + event TransferBatch( + address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values + ); + + /** + * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to + * `approved`. + */ + event ApprovalForAll(address indexed account, address indexed operator, bool approved); + + /** + * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI. + * + * If an {URI} event was emitted for `id`, the standard + * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value + * returned by {IERC1155MetadataURI-uri}. + */ + event URI(string value, uint256 indexed id); + + /** + * @dev Returns the amount of tokens of token type `id` owned by `account`. + * + * Requirements: + * + * - `account` cannot be the zero address. + */ + function balanceOf(address account, uint256 id) external view returns (uint256); + + /** + * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}. + * + * Requirements: + * + * - `accounts` and `ids` must have the same length. + */ + function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids) + external + view + returns (uint256[] memory); + + /** + * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`, + * + * Emits an {ApprovalForAll} event. + * + * Requirements: + * + * - `operator` cannot be the caller. + */ + function setApprovalForAll(address operator, bool approved) external; + + /** + * @dev Returns true if `operator` is approved to transfer ``account``'s tokens. + * + * See {setApprovalForAll}. + */ + function isApprovedForAll(address account, address operator) external view returns (bool); + + /** + * @dev Transfers `amount` tokens of token type `id` from `from` to `to`. + * + * Emits a {TransferSingle} event. + * + * Requirements: + * + * - `to` cannot be the zero address. + * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}. + * - `from` must have a balance of tokens of type `id` of at least `amount`. + * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the + * acceptance magic value. + */ + function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external; + + /** + * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}. + * + * Emits a {TransferBatch} event. + * + * Requirements: + * + * - `ids` and `amounts` must have the same length. + * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the + * acceptance magic value. + */ + function safeBatchTransferFrom( + address from, + address to, + uint256[] calldata ids, + uint256[] calldata amounts, + bytes calldata data + ) external; +} + +// File lib/openzeppelin-contracts-upgradeable/contracts/token/ERC1155/extensions/IERC1155MetadataURIUpgradeable.sol + +// Original license: SPDX_License_Identifier: MIT +// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/IERC1155MetadataURI.sol) + +pragma solidity ^0.8.0; + +/** + * @dev Interface of the optional ERC1155MetadataExtension interface, as defined + * in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP]. + * + * _Available since v3.1._ + */ +interface IERC1155MetadataURIUpgradeable is IERC1155Upgradeable { + /** + * @dev Returns the URI for token type `id`. + * + * If the `\{id\}` substring is present in the URI, it must be replaced by + * clients with the actual token type ID. + */ + function uri(uint256 id) external view returns (string memory); +} + +// File lib/openzeppelin-contracts-upgradeable/contracts/token/ERC1155/IERC1155ReceiverUpgradeable.sol + +// Original license: SPDX_License_Identifier: MIT +// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol) + +pragma solidity ^0.8.0; + +/** + * @dev _Available since v3.1._ + */ +interface IERC1155ReceiverUpgradeable is IERC165Upgradeable { + /** + * @dev Handles the receipt of a single ERC1155 token type. This function is + * called at the end of a `safeTransferFrom` after the balance has been updated. + * + * NOTE: To accept the transfer, this must return + * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` + * (i.e. 0xf23a6e61, or its own function selector). + * + * @param operator The address which initiated the transfer (i.e. msg.sender) + * @param from The address which previously owned the token + * @param id The ID of the token being transferred + * @param value The amount of tokens being transferred + * @param data Additional data with no specified format + * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed + */ + function onERC1155Received(address operator, address from, uint256 id, uint256 value, bytes calldata data) + external + returns (bytes4); + + /** + * @dev Handles the receipt of a multiple ERC1155 token types. This function + * is called at the end of a `safeBatchTransferFrom` after the balances have + * been updated. + * + * NOTE: To accept the transfer(s), this must return + * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` + * (i.e. 0xbc197c81, or its own function selector). + * + * @param operator The address which initiated the batch transfer (i.e. msg.sender) + * @param from The address which previously owned the token + * @param ids An array containing ids of each token being transferred (order and length must match values array) + * @param values An array containing amounts of each token being transferred (order and length must match ids array) + * @param data Additional data with no specified format + * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is + * allowed + */ + function onERC1155BatchReceived( + address operator, + address from, + uint256[] calldata ids, + uint256[] calldata values, + bytes calldata data + ) external returns (bytes4); +} + +// File lib/openzeppelin-contracts-upgradeable/contracts/utils/introspection/ERC165Upgradeable.sol + +// Original license: SPDX_License_Identifier: MIT +// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) + +pragma solidity ^0.8.0; + +/** + * @dev Implementation of the {IERC165} interface. + * + * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check + * for the additional interface id that will be supported. For example: + * + * ```solidity + * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { + * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); + * } + * ``` + * + * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. + */ +abstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable { + function __ERC165_init() internal onlyInitializing {} + + function __ERC165_init_unchained() internal onlyInitializing {} + /** + * @dev See {IERC165-supportsInterface}. + */ + + function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { + return interfaceId == type(IERC165Upgradeable).interfaceId; + } + + /** + * @dev This empty reserved space is put in place to allow future versions to add new + * variables without shifting down storage in the inheritance chain. + * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps + */ + uint256[50] private __gap; +} + +// File lib/openzeppelin-contracts-upgradeable/contracts/token/ERC1155/ERC1155Upgradeable.sol + +// Original license: SPDX_License_Identifier: MIT +// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/ERC1155.sol) + +pragma solidity ^0.8.0; + +/** + * @dev Implementation of the basic standard multi-token. + * See https://eips.ethereum.org/EIPS/eip-1155 + * Originally based on code by Enjin: https://github.com/enjin/erc-1155 + * + * _Available since v3.1._ + */ +contract ERC1155Upgradeable is + Initializable, + ContextUpgradeable, + ERC165Upgradeable, + IERC1155Upgradeable, + IERC1155MetadataURIUpgradeable +{ + using AddressUpgradeable for address; + + // Mapping from token ID to account balances + mapping(uint256 => mapping(address => uint256)) private _balances; + + // Mapping from account to operator approvals + mapping(address => mapping(address => bool)) private _operatorApprovals; + + // Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json + string private _uri; + + /** + * @dev See {_setURI}. + */ + function __ERC1155_init(string memory uri_) internal onlyInitializing { + __ERC1155_init_unchained(uri_); + } + + function __ERC1155_init_unchained(string memory uri_) internal onlyInitializing { + _setURI(uri_); + } + + /** + * @dev See {IERC165-supportsInterface}. + */ + function supportsInterface(bytes4 interfaceId) + public + view + virtual + override(ERC165Upgradeable, IERC165Upgradeable) + returns (bool) + { + return interfaceId == type(IERC1155Upgradeable).interfaceId + || interfaceId == type(IERC1155MetadataURIUpgradeable).interfaceId || super.supportsInterface(interfaceId); + } + + /** + * @dev See {IERC1155MetadataURI-uri}. + * + * This implementation returns the same URI for *all* token types. It relies + * on the token type ID substitution mechanism + * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP]. + * + * Clients calling this function must replace the `\{id\}` substring with the + * actual token type ID. + */ + function uri(uint256) public view virtual override returns (string memory) { + return _uri; + } + + /** + * @dev See {IERC1155-balanceOf}. + * + * Requirements: + * + * - `account` cannot be the zero address. + */ + function balanceOf(address account, uint256 id) public view virtual override returns (uint256) { + require(account != address(0), "ERC1155: address zero is not a valid owner"); + return _balances[id][account]; + } + + /** + * @dev See {IERC1155-balanceOfBatch}. + * + * Requirements: + * + * - `accounts` and `ids` must have the same length. + */ + function balanceOfBatch(address[] memory accounts, uint256[] memory ids) + public + view + virtual + override + returns (uint256[] memory) + { + require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch"); + + uint256[] memory batchBalances = new uint256[](accounts.length); + + for (uint256 i = 0; i < accounts.length; ++i) { + batchBalances[i] = balanceOf(accounts[i], ids[i]); + } + + return batchBalances; + } + + /** + * @dev See {IERC1155-setApprovalForAll}. + */ + function setApprovalForAll(address operator, bool approved) public virtual override { + _setApprovalForAll(_msgSender(), operator, approved); + } + + /** + * @dev See {IERC1155-isApprovedForAll}. + */ + function isApprovedForAll(address account, address operator) public view virtual override returns (bool) { + return _operatorApprovals[account][operator]; + } + + /** + * @dev See {IERC1155-safeTransferFrom}. + */ + function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes memory data) + public + virtual + override + { + require( + from == _msgSender() || isApprovedForAll(from, _msgSender()), + "ERC1155: caller is not token owner or approved" + ); + _safeTransferFrom(from, to, id, amount, data); + } + + /** + * @dev See {IERC1155-safeBatchTransferFrom}. + */ + function safeBatchTransferFrom( + address from, + address to, + uint256[] memory ids, + uint256[] memory amounts, + bytes memory data + ) public virtual override { + require( + from == _msgSender() || isApprovedForAll(from, _msgSender()), + "ERC1155: caller is not token owner or approved" + ); + _safeBatchTransferFrom(from, to, ids, amounts, data); + } + + /** + * @dev Transfers `amount` tokens of token type `id` from `from` to `to`. + * + * Emits a {TransferSingle} event. + * + * Requirements: + * + * - `to` cannot be the zero address. + * - `from` must have a balance of tokens of type `id` of at least `amount`. + * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the + * acceptance magic value. + */ + function _safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes memory data) + internal + virtual + { + require(to != address(0), "ERC1155: transfer to the zero address"); + + address operator = _msgSender(); + uint256[] memory ids = _asSingletonArray(id); + uint256[] memory amounts = _asSingletonArray(amount); + + _beforeTokenTransfer(operator, from, to, ids, amounts, data); + + uint256 fromBalance = _balances[id][from]; + require(fromBalance >= amount, "ERC1155: insufficient balance for transfer"); + unchecked { + _balances[id][from] = fromBalance - amount; + } + _balances[id][to] += amount; + + emit TransferSingle(operator, from, to, id, amount); + + _afterTokenTransfer(operator, from, to, ids, amounts, data); + + _doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data); + } + + /** + * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}. + * + * Emits a {TransferBatch} event. + * + * Requirements: + * + * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the + * acceptance magic value. + */ + function _safeBatchTransferFrom( + address from, + address to, + uint256[] memory ids, + uint256[] memory amounts, + bytes memory data + ) internal virtual { + require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch"); + require(to != address(0), "ERC1155: transfer to the zero address"); + + address operator = _msgSender(); + + _beforeTokenTransfer(operator, from, to, ids, amounts, data); + + for (uint256 i = 0; i < ids.length; ++i) { + uint256 id = ids[i]; + uint256 amount = amounts[i]; + + uint256 fromBalance = _balances[id][from]; + require(fromBalance >= amount, "ERC1155: insufficient balance for transfer"); + unchecked { + _balances[id][from] = fromBalance - amount; + } + _balances[id][to] += amount; + } + + emit TransferBatch(operator, from, to, ids, amounts); + + _afterTokenTransfer(operator, from, to, ids, amounts, data); + + _doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data); + } + + /** + * @dev Sets a new URI for all token types, by relying on the token type ID + * substitution mechanism + * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP]. + * + * By this mechanism, any occurrence of the `\{id\}` substring in either the + * URI or any of the amounts in the JSON file at said URI will be replaced by + * clients with the token type ID. + * + * For example, the `https://token-cdn-domain/\{id\}.json` URI would be + * interpreted by clients as + * `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json` + * for token type ID 0x4cce0. + * + * See {uri}. + * + * Because these URIs cannot be meaningfully represented by the {URI} event, + * this function emits no events. + */ + function _setURI(string memory newuri) internal virtual { + _uri = newuri; + } + + /** + * @dev Creates `amount` tokens of token type `id`, and assigns them to `to`. + * + * Emits a {TransferSingle} event. + * + * Requirements: + * + * - `to` cannot be the zero address. + * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the + * acceptance magic value. + */ + function _mint(address to, uint256 id, uint256 amount, bytes memory data) internal virtual { + require(to != address(0), "ERC1155: mint to the zero address"); + + address operator = _msgSender(); + uint256[] memory ids = _asSingletonArray(id); + uint256[] memory amounts = _asSingletonArray(amount); + + _beforeTokenTransfer(operator, address(0), to, ids, amounts, data); + + _balances[id][to] += amount; + emit TransferSingle(operator, address(0), to, id, amount); + + _afterTokenTransfer(operator, address(0), to, ids, amounts, data); + + _doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data); + } + + /** + * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}. + * + * Emits a {TransferBatch} event. + * + * Requirements: + * + * - `ids` and `amounts` must have the same length. + * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the + * acceptance magic value. + */ + function _mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data) + internal + virtual + { + require(to != address(0), "ERC1155: mint to the zero address"); + require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch"); + + address operator = _msgSender(); + + _beforeTokenTransfer(operator, address(0), to, ids, amounts, data); + + for (uint256 i = 0; i < ids.length; i++) { + _balances[ids[i]][to] += amounts[i]; + } + + emit TransferBatch(operator, address(0), to, ids, amounts); + + _afterTokenTransfer(operator, address(0), to, ids, amounts, data); + + _doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data); + } + + /** + * @dev Destroys `amount` tokens of token type `id` from `from` + * + * Emits a {TransferSingle} event. + * + * Requirements: + * + * - `from` cannot be the zero address. + * - `from` must have at least `amount` tokens of token type `id`. + */ + function _burn(address from, uint256 id, uint256 amount) internal virtual { + require(from != address(0), "ERC1155: burn from the zero address"); + + address operator = _msgSender(); + uint256[] memory ids = _asSingletonArray(id); + uint256[] memory amounts = _asSingletonArray(amount); + + _beforeTokenTransfer(operator, from, address(0), ids, amounts, ""); + + uint256 fromBalance = _balances[id][from]; + require(fromBalance >= amount, "ERC1155: burn amount exceeds balance"); + unchecked { + _balances[id][from] = fromBalance - amount; + } + + emit TransferSingle(operator, from, address(0), id, amount); + + _afterTokenTransfer(operator, from, address(0), ids, amounts, ""); + } + + /** + * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}. + * + * Emits a {TransferBatch} event. + * + * Requirements: + * + * - `ids` and `amounts` must have the same length. + */ + function _burnBatch(address from, uint256[] memory ids, uint256[] memory amounts) internal virtual { + require(from != address(0), "ERC1155: burn from the zero address"); + require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch"); + + address operator = _msgSender(); + + _beforeTokenTransfer(operator, from, address(0), ids, amounts, ""); + + for (uint256 i = 0; i < ids.length; i++) { + uint256 id = ids[i]; + uint256 amount = amounts[i]; + + uint256 fromBalance = _balances[id][from]; + require(fromBalance >= amount, "ERC1155: burn amount exceeds balance"); + unchecked { + _balances[id][from] = fromBalance - amount; + } + } + + emit TransferBatch(operator, from, address(0), ids, amounts); + + _afterTokenTransfer(operator, from, address(0), ids, amounts, ""); + } + + /** + * @dev Approve `operator` to operate on all of `owner` tokens + * + * Emits an {ApprovalForAll} event. + */ + function _setApprovalForAll(address owner, address operator, bool approved) internal virtual { + require(owner != operator, "ERC1155: setting approval status for self"); + _operatorApprovals[owner][operator] = approved; + emit ApprovalForAll(owner, operator, approved); + } + + /** + * @dev Hook that is called before any token transfer. This includes minting + * and burning, as well as batched variants. + * + * The same hook is called on both single and batched variants. For single + * transfers, the length of the `ids` and `amounts` arrays will be 1. + * + * Calling conditions (for each `id` and `amount` pair): + * + * - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens + * of token type `id` will be transferred to `to`. + * - When `from` is zero, `amount` tokens of token type `id` will be minted + * for `to`. + * - when `to` is zero, `amount` of ``from``'s tokens of token type `id` + * will be burned. + * - `from` and `to` are never both zero. + * - `ids` and `amounts` have the same, non-zero length. + * + * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. + */ + function _beforeTokenTransfer( + address operator, + address from, + address to, + uint256[] memory ids, + uint256[] memory amounts, + bytes memory data + ) internal virtual {} + + /** + * @dev Hook that is called after any token transfer. This includes minting + * and burning, as well as batched variants. + * + * The same hook is called on both single and batched variants. For single + * transfers, the length of the `id` and `amount` arrays will be 1. + * + * Calling conditions (for each `id` and `amount` pair): + * + * - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens + * of token type `id` will be transferred to `to`. + * - When `from` is zero, `amount` tokens of token type `id` will be minted + * for `to`. + * - when `to` is zero, `amount` of ``from``'s tokens of token type `id` + * will be burned. + * - `from` and `to` are never both zero. + * - `ids` and `amounts` have the same, non-zero length. + * + * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. + */ + function _afterTokenTransfer( + address operator, + address from, + address to, + uint256[] memory ids, + uint256[] memory amounts, + bytes memory data + ) internal virtual {} + + function _doSafeTransferAcceptanceCheck( + address operator, + address from, + address to, + uint256 id, + uint256 amount, + bytes memory data + ) private { + if (to.isContract()) { + try IERC1155ReceiverUpgradeable(to).onERC1155Received(operator, from, id, amount, data) returns ( + bytes4 response + ) { + if (response != IERC1155ReceiverUpgradeable.onERC1155Received.selector) { + revert("ERC1155: ERC1155Receiver rejected tokens"); + } + } catch Error(string memory reason) { + revert(reason); + } catch { + revert("ERC1155: transfer to non-ERC1155Receiver implementer"); + } + } + } + + function _doSafeBatchTransferAcceptanceCheck( + address operator, + address from, + address to, + uint256[] memory ids, + uint256[] memory amounts, + bytes memory data + ) private { + if (to.isContract()) { + try IERC1155ReceiverUpgradeable(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns ( + bytes4 response + ) { + if (response != IERC1155ReceiverUpgradeable.onERC1155BatchReceived.selector) { + revert("ERC1155: ERC1155Receiver rejected tokens"); + } + } catch Error(string memory reason) { + revert(reason); + } catch { + revert("ERC1155: transfer to non-ERC1155Receiver implementer"); + } + } + } + + function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) { + uint256[] memory array = new uint256[](1); + array[0] = element; + + return array; + } + + /** + * @dev This empty reserved space is put in place to allow future versions to add new + * variables without shifting down storage in the inheritance chain. + * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps + */ + uint256[47] private __gap; +} + +// File lib/openzeppelin-contracts-upgradeable/contracts/token/ERC1155/extensions/ERC1155BurnableUpgradeable.sol + +// Original license: SPDX_License_Identifier: MIT +// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/extensions/ERC1155Burnable.sol) + +pragma solidity ^0.8.0; + +/** + * @dev Extension of {ERC1155} that allows token holders to destroy both their + * own tokens and those that they have been approved to use. + * + * _Available since v3.1._ + */ +abstract contract ERC1155BurnableUpgradeable is Initializable, ERC1155Upgradeable { + function __ERC1155Burnable_init() internal onlyInitializing {} + + function __ERC1155Burnable_init_unchained() internal onlyInitializing {} + + function burn(address account, uint256 id, uint256 value) public virtual { + require( + account == _msgSender() || isApprovedForAll(account, _msgSender()), + "ERC1155: caller is not token owner or approved" + ); + + _burn(account, id, value); + } + + function burnBatch(address account, uint256[] memory ids, uint256[] memory values) public virtual { + require( + account == _msgSender() || isApprovedForAll(account, _msgSender()), + "ERC1155: caller is not token owner or approved" + ); + + _burnBatch(account, ids, values); + } + + /** + * @dev This empty reserved space is put in place to allow future versions to add new + * variables without shifting down storage in the inheritance chain. + * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps + */ + uint256[50] private __gap; +} + +// File lib/openzeppelin-contracts-upgradeable/contracts/utils/math/MathUpgradeable.sol + +// Original license: SPDX_License_Identifier: MIT +// OpenZeppelin Contracts (last updated v4.7.0) (utils/math/Math.sol) + +pragma solidity ^0.8.0; + +/** + * @dev Standard math utilities missing in the Solidity language. + */ +library MathUpgradeable { + enum Rounding { + Down, // Toward negative infinity + Up, // Toward infinity + Zero // Toward zero + + } + + /** + * @dev Returns the largest of two numbers. + */ + function max(uint256 a, uint256 b) internal pure returns (uint256) { + return a > b ? a : b; + } + + /** + * @dev Returns the smallest of two numbers. + */ + function min(uint256 a, uint256 b) internal pure returns (uint256) { + return a < b ? a : b; + } + + /** + * @dev Returns the average of two numbers. The result is rounded towards + * zero. + */ + function average(uint256 a, uint256 b) internal pure returns (uint256) { + // (a + b) / 2 can overflow. + return (a & b) + (a ^ b) / 2; + } + + /** + * @dev Returns the ceiling of the division of two numbers. + * + * This differs from standard division with `/` in that it rounds up instead + * of rounding down. + */ + function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { + // (a + b - 1) / b can overflow on addition, so we distribute. + return a == 0 ? 0 : (a - 1) / b + 1; + } + + /** + * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or + * denominator == 0 + * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) + * with further edits by Uniswap Labs also under MIT license. + */ + function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) { + unchecked { + // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use + // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 + // variables such that product = prod1 * 2^256 + prod0. + uint256 prod0; // Least significant 256 bits of the product + uint256 prod1; // Most significant 256 bits of the product + assembly { + let mm := mulmod(x, y, not(0)) + prod0 := mul(x, y) + prod1 := sub(sub(mm, prod0), lt(mm, prod0)) + } + + // Handle non-overflow cases, 256 by 256 division. + if (prod1 == 0) { + return prod0 / denominator; + } + + // Make sure the result is less than 2^256. Also prevents denominator == 0. + require(denominator > prod1); + + /////////////////////////////////////////////// + // 512 by 256 division. + /////////////////////////////////////////////// + + // Make division exact by subtracting the remainder from [prod1 prod0]. + uint256 remainder; + assembly { + // Compute remainder using mulmod. + remainder := mulmod(x, y, denominator) + + // Subtract 256 bit number from 512 bit number. + prod1 := sub(prod1, gt(remainder, prod0)) + prod0 := sub(prod0, remainder) + } + + // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always + // >= 1. + // See https://cs.stackexchange.com/q/138556/92363. + + // Does not overflow because the denominator cannot be zero at this stage in the function. + uint256 twos = denominator & (~denominator + 1); + assembly { + // Divide denominator by twos. + denominator := div(denominator, twos) + + // Divide [prod1 prod0] by twos. + prod0 := div(prod0, twos) + + // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. + twos := add(div(sub(0, twos), twos), 1) + } + + // Shift in bits from prod1 into prod0. + prod0 |= prod1 * twos; + + // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such + // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for + // four bits. That is, denominator * inv = 1 mod 2^4. + uint256 inverse = (3 * denominator) ^ 2; + + // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also + // works + // in modular arithmetic, doubling the correct bits in each step. + inverse *= 2 - denominator * inverse; // inverse mod 2^8 + inverse *= 2 - denominator * inverse; // inverse mod 2^16 + inverse *= 2 - denominator * inverse; // inverse mod 2^32 + inverse *= 2 - denominator * inverse; // inverse mod 2^64 + inverse *= 2 - denominator * inverse; // inverse mod 2^128 + inverse *= 2 - denominator * inverse; // inverse mod 2^256 + + // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. + // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is + // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 + // is no longer required. + result = prod0 * inverse; + return result; + } + } + + /** + * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. + */ + function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) { + uint256 result = mulDiv(x, y, denominator); + if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) { + result += 1; + } + return result; + } + + /** + * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down. + * + * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). + */ + function sqrt(uint256 a) internal pure returns (uint256) { + if (a == 0) { + return 0; + } + + // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. + // + // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have + // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. + // + // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` + // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` + // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` + // + // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. + uint256 result = 1 << (log2(a) >> 1); + + // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, + // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at + // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision + // into the expected uint128 result. + unchecked { + result = (result + a / result) >> 1; + result = (result + a / result) >> 1; + result = (result + a / result) >> 1; + result = (result + a / result) >> 1; + result = (result + a / result) >> 1; + result = (result + a / result) >> 1; + result = (result + a / result) >> 1; + return min(result, a / result); + } + } + + /** + * @notice Calculates sqrt(a), following the selected rounding direction. + */ + function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { + unchecked { + uint256 result = sqrt(a); + return result + (rounding == Rounding.Up && result * result < a ? 1 : 0); + } + } + + /** + * @dev Return the log in base 2, rounded down, of a positive value. + * Returns 0 if given 0. + */ + function log2(uint256 value) internal pure returns (uint256) { + uint256 result = 0; + unchecked { + if (value >> 128 > 0) { + value >>= 128; + result += 128; + } + if (value >> 64 > 0) { + value >>= 64; + result += 64; + } + if (value >> 32 > 0) { + value >>= 32; + result += 32; + } + if (value >> 16 > 0) { + value >>= 16; + result += 16; + } + if (value >> 8 > 0) { + value >>= 8; + result += 8; + } + if (value >> 4 > 0) { + value >>= 4; + result += 4; + } + if (value >> 2 > 0) { + value >>= 2; + result += 2; + } + if (value >> 1 > 0) { + result += 1; + } + } + return result; + } + + /** + * @dev Return the log in base 2, following the selected rounding direction, of a positive value. + * Returns 0 if given 0. + */ + function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { + unchecked { + uint256 result = log2(value); + return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0); + } + } + + /** + * @dev Return the log in base 10, rounded down, of a positive value. + * Returns 0 if given 0. + */ + function log10(uint256 value) internal pure returns (uint256) { + uint256 result = 0; + unchecked { + if (value >= 10 ** 64) { + value /= 10 ** 64; + result += 64; + } + if (value >= 10 ** 32) { + value /= 10 ** 32; + result += 32; + } + if (value >= 10 ** 16) { + value /= 10 ** 16; + result += 16; + } + if (value >= 10 ** 8) { + value /= 10 ** 8; + result += 8; + } + if (value >= 10 ** 4) { + value /= 10 ** 4; + result += 4; + } + if (value >= 10 ** 2) { + value /= 10 ** 2; + result += 2; + } + if (value >= 10 ** 1) { + result += 1; + } + } + return result; + } + + /** + * @dev Return the log in base 10, following the selected rounding direction, of a positive value. + * Returns 0 if given 0. + */ + function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { + unchecked { + uint256 result = log10(value); + return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0); + } + } + + /** + * @dev Return the log in base 256, rounded down, of a positive value. + * Returns 0 if given 0. + * + * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. + */ + function log256(uint256 value) internal pure returns (uint256) { + uint256 result = 0; + unchecked { + if (value >> 128 > 0) { + value >>= 128; + result += 16; + } + if (value >> 64 > 0) { + value >>= 64; + result += 8; + } + if (value >> 32 > 0) { + value >>= 32; + result += 4; + } + if (value >> 16 > 0) { + value >>= 16; + result += 2; + } + if (value >> 8 > 0) { + result += 1; + } + } + return result; + } + + /** + * @dev Return the log in base 10, following the selected rounding direction, of a positive value. + * Returns 0 if given 0. + */ + function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { + unchecked { + uint256 result = log256(value); + return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0); + } + } +} + +// File lib/openzeppelin-contracts-upgradeable/contracts/utils/StringsUpgradeable.sol + +// Original license: SPDX_License_Identifier: MIT +// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol) + +pragma solidity ^0.8.0; + +/** + * @dev String operations. + */ +library StringsUpgradeable { + bytes16 private constant _SYMBOLS = "0123456789abcdef"; + uint8 private constant _ADDRESS_LENGTH = 20; + + /** + * @dev Converts a `uint256` to its ASCII `string` decimal representation. + */ + function toString(uint256 value) internal pure returns (string memory) { + unchecked { + uint256 length = MathUpgradeable.log10(value) + 1; + string memory buffer = new string(length); + uint256 ptr; + /// @solidity memory-safe-assembly + assembly { + ptr := add(buffer, add(32, length)) + } + while (true) { + ptr--; + /// @solidity memory-safe-assembly + assembly { + mstore8(ptr, byte(mod(value, 10), _SYMBOLS)) + } + value /= 10; + if (value == 0) break; + } + return buffer; + } + } + + /** + * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. + */ + function toHexString(uint256 value) internal pure returns (string memory) { + unchecked { + return toHexString(value, MathUpgradeable.log256(value) + 1); + } + } + + /** + * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. + */ + function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { + bytes memory buffer = new bytes(2 * length + 2); + buffer[0] = "0"; + buffer[1] = "x"; + for (uint256 i = 2 * length + 1; i > 1; --i) { + buffer[i] = _SYMBOLS[value & 0xf]; + value >>= 4; + } + require(value == 0, "Strings: hex length insufficient"); + return string(buffer); + } + + /** + * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal + * representation. + */ + function toHexString(address addr) internal pure returns (string memory) { + return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); + } +} + +// File lib/openzeppelin-contracts-upgradeable/contracts/token/ERC1155/extensions/ERC1155URIStorageUpgradeable.sol + +// Original license: SPDX_License_Identifier: MIT +// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC1155/extensions/ERC1155URIStorage.sol) + +pragma solidity ^0.8.0; + +/** + * @dev ERC1155 token with storage based token URI management. + * Inspired by the ERC721URIStorage extension + * + * _Available since v4.6._ + */ +abstract contract ERC1155URIStorageUpgradeable is Initializable, ERC1155Upgradeable { + function __ERC1155URIStorage_init() internal onlyInitializing { + __ERC1155URIStorage_init_unchained(); + } + + function __ERC1155URIStorage_init_unchained() internal onlyInitializing { + _baseURI = ""; + } + + using StringsUpgradeable for uint256; + + // Optional base URI + string private _baseURI; + + // Optional mapping for token URIs + mapping(uint256 => string) private _tokenURIs; + + /** + * @dev See {IERC1155MetadataURI-uri}. + * + * This implementation returns the concatenation of the `_baseURI` + * and the token-specific uri if the latter is set + * + * This enables the following behaviors: + * + * - if `_tokenURIs[tokenId]` is set, then the result is the concatenation + * of `_baseURI` and `_tokenURIs[tokenId]` (keep in mind that `_baseURI` + * is empty per default); + * + * - if `_tokenURIs[tokenId]` is NOT set then we fallback to `super.uri()` + * which in most cases will contain `ERC1155._uri`; + * + * - if `_tokenURIs[tokenId]` is NOT set, and if the parents do not have a + * uri value set, then the result is empty. + */ + function uri(uint256 tokenId) public view virtual override returns (string memory) { + string memory tokenURI = _tokenURIs[tokenId]; + + // If token URI is set, concatenate base URI and tokenURI (via abi.encodePacked). + return bytes(tokenURI).length > 0 ? string(abi.encodePacked(_baseURI, tokenURI)) : super.uri(tokenId); + } + + /** + * @dev Sets `tokenURI` as the tokenURI of `tokenId`. + */ + function _setURI(uint256 tokenId, string memory tokenURI) internal virtual { + _tokenURIs[tokenId] = tokenURI; + emit URI(uri(tokenId), tokenId); + } + + /** + * @dev Sets `baseURI` as the `_baseURI` for all tokens + */ + function _setBaseURI(string memory baseURI) internal virtual { + _baseURI = baseURI; + } + + /** + * @dev This empty reserved space is put in place to allow future versions to add new + * variables without shifting down storage in the inheritance chain. + * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps + */ + uint256[48] private __gap; +} + +// File lib/openzeppelin-contracts-upgradeable/contracts/utils/cryptography/MerkleProofUpgradeable.sol + +// Original license: SPDX_License_Identifier: MIT +// OpenZeppelin Contracts (last updated v4.7.0) (utils/cryptography/MerkleProof.sol) + +pragma solidity ^0.8.0; + +/** + * @dev These functions deal with verification of Merkle Tree proofs. + * + * The tree and the proofs can be generated using our + * https://github.com/OpenZeppelin/merkle-tree[JavaScript library]. + * You will find a quickstart guide in the readme. + * + * WARNING: You should avoid using leaf values that are 64 bytes long prior to + * hashing, or use a hash function other than keccak256 for hashing leaves. + * This is because the concatenation of a sorted pair of internal nodes in + * the merkle tree could be reinterpreted as a leaf value. + * OpenZeppelin's JavaScript library generates merkle trees that are safe + * against this attack out of the box. + */ +library MerkleProofUpgradeable { + /** + * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree + * defined by `root`. For this, a `proof` must be provided, containing + * sibling hashes on the branch from the leaf to the root of the tree. Each + * pair of leaves and each pair of pre-images are assumed to be sorted. + */ + function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) { + return processProof(proof, leaf) == root; + } + + /** + * @dev Calldata version of {verify} + * + * _Available since v4.7._ + */ + function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) { + return processProofCalldata(proof, leaf) == root; + } + + /** + * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up + * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt + * hash matches the root of the tree. When processing the proof, the pairs + * of leafs & pre-images are assumed to be sorted. + * + * _Available since v4.4._ + */ + function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) { + bytes32 computedHash = leaf; + for (uint256 i = 0; i < proof.length; i++) { + computedHash = _hashPair(computedHash, proof[i]); + } + return computedHash; + } + + /** + * @dev Calldata version of {processProof} + * + * _Available since v4.7._ + */ + function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) { + bytes32 computedHash = leaf; + for (uint256 i = 0; i < proof.length; i++) { + computedHash = _hashPair(computedHash, proof[i]); + } + return computedHash; + } + + /** + * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by + * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}. + * + * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details. + * + * _Available since v4.7._ + */ + function multiProofVerify(bytes32[] memory proof, bool[] memory proofFlags, bytes32 root, bytes32[] memory leaves) + internal + pure + returns (bool) + { + return processMultiProof(proof, proofFlags, leaves) == root; + } + + /** + * @dev Calldata version of {multiProofVerify} + * + * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details. + * + * _Available since v4.7._ + */ + function multiProofVerifyCalldata( + bytes32[] calldata proof, + bool[] calldata proofFlags, + bytes32 root, + bytes32[] memory leaves + ) internal pure returns (bool) { + return processMultiProofCalldata(proof, proofFlags, leaves) == root; + } + + /** + * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction + * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another + * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false + * respectively. + * + * CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree + * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the + * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer). + * + * _Available since v4.7._ + */ + function processMultiProof(bytes32[] memory proof, bool[] memory proofFlags, bytes32[] memory leaves) + internal + pure + returns (bytes32 merkleRoot) + { + // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by + // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the + // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of + // the merkle tree. + uint256 leavesLen = leaves.length; + uint256 totalHashes = proofFlags.length; + + // Check proof validity. + require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof"); + + // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using + // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop". + bytes32[] memory hashes = new bytes32[](totalHashes); + uint256 leafPos = 0; + uint256 hashPos = 0; + uint256 proofPos = 0; + // At each step, we compute the next hash using two values: + // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we + // get the next hash. + // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the + // `proof` array. + for (uint256 i = 0; i < totalHashes; i++) { + bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++]; + bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++]; + hashes[i] = _hashPair(a, b); + } + + if (totalHashes > 0) { + return hashes[totalHashes - 1]; + } else if (leavesLen > 0) { + return leaves[0]; + } else { + return proof[0]; + } + } + + /** + * @dev Calldata version of {processMultiProof}. + * + * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details. + * + * _Available since v4.7._ + */ + function processMultiProofCalldata(bytes32[] calldata proof, bool[] calldata proofFlags, bytes32[] memory leaves) + internal + pure + returns (bytes32 merkleRoot) + { + // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by + // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the + // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of + // the merkle tree. + uint256 leavesLen = leaves.length; + uint256 totalHashes = proofFlags.length; + + // Check proof validity. + require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof"); + + // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using + // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop". + bytes32[] memory hashes = new bytes32[](totalHashes); + uint256 leafPos = 0; + uint256 hashPos = 0; + uint256 proofPos = 0; + // At each step, we compute the next hash using two values: + // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we + // get the next hash. + // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the + // `proof` array. + for (uint256 i = 0; i < totalHashes; i++) { + bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++]; + bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++]; + hashes[i] = _hashPair(a, b); + } + + if (totalHashes > 0) { + return hashes[totalHashes - 1]; + } else if (leavesLen > 0) { + return leaves[0]; + } else { + return proof[0]; + } + } + + function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) { + return a < b ? _efficientHash(a, b) : _efficientHash(b, a); + } + + function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) { + /// @solidity memory-safe-assembly + assembly { + mstore(0x00, a) + mstore(0x20, b) + value := keccak256(0x00, 0x40) + } + } +} + +// File src/protocol/interfaces/IAllowlist.sol + +// Original license: SPDX_License_Identifier: MIT +pragma solidity 0.8.17; + +/// @title Interface for allowlist +/// @author bitbeckers +/// @notice This interface declares the required functionality for a hypercert token +/// @notice This interface does not specify the underlying token type (e.g. 721 or 1155) +interface IAllowlist { + function isAllowedToClaim(bytes32[] calldata proof, uint256 tokenID, bytes32 leaf) + external + view + returns (bool isAllowed); +} + +// File src/protocol/libs/Errors.sol + +// Original license: SPDX_License_Identifier: MIT +pragma solidity 0.8.17; + +/// @author bitbeckers +library Errors { + error AlreadyClaimed(); + error ArraySize(); + error DoesNotExist(); + error DuplicateEntry(); + error Invalid(); + error NotAllowed(); + error NotApprovedOrOwner(); + error TransfersNotAllowed(); + error TypeMismatch(); +} + +// File src/protocol/AllowlistMinter.sol + +// Original license: SPDX_License_Identifier: MIT +pragma solidity 0.8.17; + +/// @title Interface for hypercert token interactions +/// @author bitbeckers +/// @notice This interface declares the required functionality for a hypercert token +/// @notice This interface does not specify the underlying token type (e.g. 721 or 1155) +contract AllowlistMinter is IAllowlist { + event AllowlistCreated(uint256 tokenID, bytes32 root); + event LeafClaimed(uint256 tokenID, bytes32 leaf); + + mapping(uint256 => bytes32) internal merkleRoots; + mapping(uint256 => mapping(bytes32 => bool)) public hasBeenClaimed; + mapping(uint256 => uint256) internal maxUnits; + mapping(uint256 => uint256) internal minted; + + function getMinted(uint256 claimID) external view returns (uint256 mintedUnits) { + mintedUnits = minted[claimID]; + } + + function isAllowedToClaim(bytes32[] calldata proof, uint256 claimID, bytes32 leaf) + external + view + returns (bool isAllowed) + { + if (merkleRoots[claimID].length == 0) revert Errors.DoesNotExist(); + isAllowed = MerkleProofUpgradeable.verifyCalldata(proof, merkleRoots[claimID], leaf); + } + + function _createAllowlist(uint256 claimID, bytes32 merkleRoot, uint256 units) internal { + if (merkleRoot == "" || units == 0) revert Errors.Invalid(); + if (merkleRoots[claimID] != "") revert Errors.DuplicateEntry(); + + merkleRoots[claimID] = merkleRoot; + maxUnits[claimID] = units; + emit AllowlistCreated(claimID, merkleRoot); + } + + function _processClaim(bytes32[] calldata proof, uint256 claimID, uint256 amount) internal { + if (merkleRoots[claimID].length == 0) revert Errors.DoesNotExist(); + + bytes32 leaf = _calculateLeaf(msg.sender, amount); + + if (hasBeenClaimed[claimID][leaf]) revert Errors.AlreadyClaimed(); + if ( + !MerkleProofUpgradeable.verifyCalldata(proof, merkleRoots[claimID], leaf) + || (minted[claimID] + amount) > maxUnits[claimID] + ) revert Errors.Invalid(); + hasBeenClaimed[claimID][leaf] = true; + + minted[claimID] += amount; + + emit LeafClaimed(claimID, leaf); + } + + function _calculateLeaf(address account, uint256 amount) internal pure returns (bytes32 leaf) { + leaf = keccak256(bytes.concat(keccak256(abi.encode(account, amount)))); + } + + /** + * @dev This empty reserved space is put in place to allow future versions to add new + * variables without shifting down storage in the inheritance chain. + * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps + * Assuming 30 available slots (slots cost space, cost gas) + * 1. merkleRoots + * 2. hasBeenClaimed + * 3. maxUnits + * 4. minted + */ + uint256[26] private __gap; +} + +// File src/protocol/interfaces/IHypercertToken.sol + +// Original license: SPDX_License_Identifier: MIT +pragma solidity 0.8.17; + +/// @title Interface for hypercert token interactions +/// @author bitbeckers +/// @notice This interface declares the required functionality for a hypercert token +/// @notice This interface does not specify the underlying token type (e.g. 721 or 1155) +interface IHypercertToken { + /** + * AllowAll = Unrestricted + * DisallowAll = Transfers disabled after minting + * FromCreatorOnly = Only the original creator can transfer + */ + /// @dev Transfer restriction policies on hypercerts + enum TransferRestrictions { + AllowAll, + DisallowAll, + FromCreatorOnly + } + + /// @dev Emitted when token with tokenID `claimID` is stored, with external data reference via `uri`. + event ClaimStored(uint256 indexed claimID, string uri, uint256 totalUnits); + + /// @dev Function called to store a claim referenced via `uri` with a maximum number of fractions `units`. + function mintClaim(address account, uint256 units, string memory uri, TransferRestrictions restrictions) external; + + /// @dev Function called to store a claim referenced via `uri` with a set of `fractions`. + /// @dev Fractions are internally summed to total units. + function mintClaimWithFractions( + address account, + uint256 units, + uint256[] memory fractions, + string memory uri, + TransferRestrictions restrictions + ) external; + + /// @dev Function called to split `tokenID` and transfer `to` into units declared in `values`. + /// @notice The sum of `values` must equal the current value of `_tokenID`. + function splitFraction(address to, uint256 tokenID, uint256[] memory _values) external; + + /// @dev Function called to merge tokens within `tokenIDs`. + /// @notice Tokens that have been merged are burned. + function mergeFractions(address account, uint256[] memory tokenIDs) external; + + /// @dev Function to burn the token at `tokenID` for `account` + /// @notice Operator must be allowed by `creator` and the token must represent the total amount of available units. + function burnFraction(address account, uint256 tokenID) external; + + /// @dev Function to burn the tokens at `tokenIDs` for `account` + /// @notice Operator must be allowed by `creator` and the tokens must represent the total amount of available units. + function batchBurnFraction(address account, uint256[] memory tokenIDs) external; + + /// @dev Returns the `units` held by a (fractional) token at `claimID` + /// @dev If `tokenID` is a base type, the total amount of `units` for the claim is returned. + /// @dev If `tokenID` is a fractional token, the `units` held by the token is returned + function unitsOf(uint256 tokenID) external view returns (uint256 units); + + /// @dev Returns the `units` held by `account` of a (fractional) token at `claimID` + /// @dev If `tokenID` is a base type, the total amount of `units` held by `account` for the claim is returned. + /// @dev If `tokenID` is a fractional token, the `units` held by `account` the token is returned + function unitsOf(address account, uint256 tokenID) external view returns (uint256 units); + + /// @dev Returns the `uri` for metadata of the claim represented by `tokenID` + /// @dev Metadata must conform to { Hypercert Metadata } spec (based on ERC1155 Metadata) + function uri(uint256 tokenID) external view returns (string memory metadata); +} + +// File src/protocol/SemiFungible1155.sol + +// Original license: SPDX_License_Identifier: MIT +// Used components of Enjin example implementation for mixed fungibility +// https://github.com/enjin/erc-1155/blob/master/contracts/ERC1155MixedFungibleMintable.sol +pragma solidity 0.8.17; + +/// @title Contract for minting semi-fungible EIP1155 tokens +/// @author bitbeckers +/// @notice Extends { Upgradeable1155 } token with semi-fungible properties and the concept of `units` +/// @dev Adds split bit strategy as described in [EIP-1155](https://eips.ethereum.org/EIPS/eip-1155#non-fungible-tokens) +contract SemiFungible1155 is + Initializable, + ERC1155Upgradeable, + ERC1155BurnableUpgradeable, + ERC1155URIStorageUpgradeable, + OwnableUpgradeable, + UUPSUpgradeable +{ + /// @dev Counter used to generate next typeID. + uint256 internal typeCounter; + + /// @dev Bitmask used to expose only upper 128 bits of uint256 + uint256 internal constant TYPE_MASK = type(uint256).max << 128; + + /// @dev Bitmask used to expose only lower 128 bits of uint256 + uint256 internal constant NF_INDEX_MASK = type(uint256).max >> 128; + + uint256 internal constant FRACTION_LIMIT = 253; + + /// @dev Mapping of `tokenID` to address of `owner` + mapping(uint256 => address) internal owners; + + /// @dev Mapping of `tokenID` to address of `creator` + mapping(uint256 => address) internal creators; + + /// @dev Used to determine amount of `units` stored in token at `tokenID` + mapping(uint256 => uint256) internal tokenValues; + + /// @dev Used to find highest index of token belonging to token at `typeID` + mapping(uint256 => uint256) internal maxIndex; + + /// @dev Emitted on transfer of `value` between `fromTokenID` to `toTokenID` of the same `claimID` + event ValueTransfer(uint256 claimID, uint256 fromTokenID, uint256 toTokenID, uint256 value); + + /// @dev Emitted on transfer of `values` between `fromTokenIDs` to `toTokenIDs` of `claimIDs` + event BatchValueTransfer(uint256[] claimIDs, uint256[] fromTokenIDs, uint256[] toTokenIDs, uint256[] values); + + /// @dev see { openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol } + // solhint-disable-next-line func-name-mixedcase + function __SemiFungible1155_init() public virtual onlyInitializing { + __ERC1155_init(""); + __ERC1155Burnable_init(); + __ERC1155URIStorage_init(); + __Ownable_init(); + __UUPSUpgradeable_init(); + } + + /** + * @dev Returns the index of the fractional token at `_id` by returning lower 128 bit values. + * @param tokenID The ID of the token to query. + * @return The index of the fractional token. + * @dev This function returns 0 if `_id` is a baseType. + */ + function getItemIndex(uint256 tokenID) internal pure returns (uint256) { + return tokenID & NF_INDEX_MASK; + } + + /** + * @dev Get base type ID for token at `_id` by returning upper 128 bit values. + * @param tokenID The ID of the token to query. + * @return The base type ID of the token. + */ + function getBaseType(uint256 tokenID) internal pure returns (uint256) { + return tokenID & TYPE_MASK; + } + + /** + * @dev Identify that token at `_id` is base type. + * @param tokenID The ID of the token to query. + * @return A boolean indicating whether the token is a base type. + * @dev Upper 128 bits identify base type ID, lower bits should be 0. + */ + function isBaseType(uint256 tokenID) internal pure returns (bool) { + return (tokenID & TYPE_MASK == tokenID) && (tokenID & NF_INDEX_MASK == 0); + } + + /** + * @dev Returns a boolean indicating whether the token at `_id` belongs to a base type. + * @param tokenID The ID of the token to query. + * @return A boolean indicating whether the token is a typed item. + * @dev Upper 128 bits identify the type ID, lower bits identify the index of the typed item. + */ + function isTypedItem(uint256 tokenID) internal pure returns (bool) { + return (tokenID & TYPE_MASK != 0) && (tokenID & NF_INDEX_MASK != 0); + } + + /// READ + /** + * @dev Returns the owner of a given token ID. + * @param tokenID The ID of the token to query. + * @return _owner The address of the owner of the token. + */ + function ownerOf(uint256 tokenID) public view returns (address _owner) { + _owner = owners[tokenID]; + } + + /** + * @dev Returns the number of units of a given token ID. + * @param tokenID The ID of the token to query. + * @return units The number of units of the token. + * @dev This function is used internally to get the number of units of a token. + */ + function _unitsOf(uint256 tokenID) internal view returns (uint256 units) { + units = tokenValues[tokenID]; + } + + /** + * @dev Returns the number of units of a given token ID owned by a given account. + * @param account The address of the account to query. + * @param tokenID The ID of the token to query. + * @return units The number of units of the token owned by the account. + * @dev This function is used internally to get the number of units of a token owned by an account. + */ + function _unitsOf(address account, uint256 tokenID) internal view returns (uint256 units) { + // Check if fraction token and accounts owns it + if (ownerOf(tokenID) == account) { + units = tokenValues[tokenID]; + } + } + + /// MUTATE + + /** + * @dev Creates a new token type ID based on the token counter. + * @param _account The address of the account that will own the new token type. + * @param units The number of units associated with the new token type. + * @param _uri The URI for the metadata associated with the new token type. + * @return typeID The new token type ID. + */ + function _createTokenType(address _account, uint256 units, string memory _uri) internal returns (uint256 typeID) { + _notMaxType(typeCounter); + typeID = ++typeCounter << 128; + + creators[typeID] = _account; + tokenValues[typeID] = units; + + _setURI(typeID, _uri); + + //Event emitted for indexing purposes + emit TransferSingle(_account, address(0), address(0), typeID, 0); + } + + /** + * @dev Mints a new token with a new token type ID and assigns it to the specified account. + * @param _account The address of the account that will receive the new token. + * @param _units The number of units associated with the new token. + * @param _uri The URI for the metadata associated with the new token. + * @return typeID The new token type ID. + * @dev This function creates a new token type ID by calling the `_createTokenType` function and then mints a new + * token with the new type ID. + * @dev The `tokenID` is calculated by adding the `typeID` to the current maximum index for the `typeID`. + * @dev The `tokenValues` mapping is updated with the number of units associated with the new token. + * @dev A `ValueTransfer` event is emitted to indicate that a new token has been minted and assigned to the + * specified account. + * @dev If `_units` is zero, the function will revert with an error. + */ + function _mintNewTypeWithToken(address _account, uint256 _units, string memory _uri) + internal + returns (uint256 typeID) + { + if (_units == 0) { + revert Errors.NotAllowed(); + } + typeID = _createTokenType(_account, _units, _uri); + + uint256 tokenID = typeID + ++maxIndex[typeID]; //1 based indexing, 0 holds type data + + tokenValues[tokenID] = _units; + + _mint(_account, tokenID, 1, ""); + emit ValueTransfer(typeID, 0, tokenID, _units); + } + + /** + * @dev Mints a new token with a new token type ID and assigns it to the specified account. + * @param _account The address of the account that will receive the new token. + * @param _fractions An array of values associated with the new token. + * @param _uri The URI for the metadata associated with the new token. + * @return typeID The new token type ID. + * @dev This function creates a new token type ID by calling the `_createTokenType` function and then mints a new + * token with the new type ID. + * @dev The `tokenID` is calculated by adding the `typeID` to the current maximum index for the `typeID`. + * @dev The `tokenValues` mapping is updated with the number of units associated with the new token. + * @dev A `ValueTransfer` event is emitted to indicate that a new token has been minted and assigned to the + * specified account. + * @dev If any of the fractional values in `_fractions` are zero, the function will revert with an error. + * @dev This function also calls the `_splitTokenUnits` function to split the new token into multiple sub-tokens + * with the specified fractional values. + */ + function _mintNewTypeWithTokens(address _account, uint256[] calldata _fractions, string memory _uri) + internal + returns (uint256 typeID) + { + typeID = _mintNewTypeWithToken(_account, _getSum(_fractions), _uri); + _splitTokenUnits(_account, typeID + maxIndex[typeID], _fractions); + } + + /** + * @dev Mints a new token with the specified token type ID and assigns it to the specified account. + * @param _account The address of the account that will receive the new token. + * @param _typeID The ID of the token type to mint. + * @param _units The number of units associated with the new token. + * @return tokenID The ID of the newly minted token. + * @dev This function checks that the specified token type ID is a base type and that the maximum number of tokens + * for the token type has not been reached. + * @dev The function then calculates the new token ID by adding the specified token type ID to the current maximum + * index for the token type. + * @dev The `tokenValues` mapping is updated with the number of units associated with the new token. + * @dev A `ValueTransfer` event is emitted to indicate that a new token has been minted and assigned to the + * specified account. + */ + function _mintToken(address _account, uint256 _typeID, uint256 _units) internal returns (uint256 tokenID) { + if (!isBaseType(_typeID)) revert Errors.NotAllowed(); + + _notMaxItem(maxIndex[_typeID]); + + unchecked { + tokenID = _typeID + ++maxIndex[_typeID]; //1 based indexing, 0 holds type data + } + + tokenValues[tokenID] = _units; + + _mint(_account, tokenID, 1, ""); + emit ValueTransfer(_typeID, 0, tokenID, _units); + } + + /** + * @dev Mints multiple tokens with the specified token type IDs and assigns them to the specified account. + * @param _account The address of the account that will receive the new tokens. + * @param _typeIDs An array of token type IDs to mint. + * @param _units An array of numbers of units associated with the new tokens. + * @return tokenIDs An array of the IDs of the newly minted tokens. + * @dev This function checks that each specified token type ID is a base type and that the maximum number of tokens + * for each token type has not been reached. + * @dev The function then calculates the new token IDs by adding the specified token type IDs to the current maximum + * index for each token type. + * @dev The `tokenValues` mapping is updated with the number of units associated with each new token. + * @dev A `BatchValueTransfer` event is emitted to indicate that new tokens have been minted and assigned to the + * specified account. + */ + function _batchMintTokens(address _account, uint256[] calldata _typeIDs, uint256[] calldata _units) + internal + returns (uint256[] memory tokenIDs) + { + uint256 len = _typeIDs.length; + + tokenIDs = new uint256[](len); + uint256[] memory amounts = new uint256[](len); + uint256[] memory zeroes = new uint256[](len); + + for (uint256 i; i < len;) { + uint256 _typeID = _typeIDs[i]; + if (!isBaseType(_typeID)) revert Errors.NotAllowed(); + _notMaxItem(maxIndex[_typeID]); + + unchecked { + uint256 tokenID = _typeID + ++maxIndex[_typeID]; //1 based indexing, 0 holds type data + tokenValues[tokenID] = _units[i]; + tokenIDs[i] = tokenID; + amounts[i] = 1; + ++i; + } + } + + _mintBatch(_account, tokenIDs, amounts, ""); + emit BatchValueTransfer(_typeIDs, zeroes, tokenIDs, _units); + } + + /** + * @dev Splits a token into multiple tokens with different unit values. + * @param _account The address of the account that will receive the new tokens. + * @param _tokenID The ID of the token to split. + * @param _values An array of numbers of units associated with the new tokens. + * @dev This function splits a token into multiple tokens with different unit values. + * @dev The `_values` array specifies the number of units associated with each new token. + * @dev The function checks that the length of the `_values` array is between 2 and `FRACTION_LIMIT`, and that the + * sum of the values in the `_values` array is equal to the number of units associated with the original token. + * @dev The function then creates new tokens with the specified unit values and assigns them to the specified + * account. + * @dev A `BatchValueTransfer` event is emitted to indicate that the original token has been split into multiple + * tokens. + */ + function _splitTokenUnits(address _account, uint256 _tokenID, uint256[] calldata _values) internal { + if (_values.length > FRACTION_LIMIT || _values.length < 2) revert Errors.ArraySize(); + if (tokenValues[_tokenID] != _getSum(_values)) revert Errors.NotAllowed(); + + // Current token + uint256 _typeID = getBaseType(_tokenID); + uint256 valueLeft = tokenValues[_tokenID]; + + // Prepare batch processing, we want to skip the first entry + uint256 len = _values.length - 1; + + uint256[] memory typeIDs = new uint256[](len); + uint256[] memory fromIDs = new uint256[](len); + uint256[] memory toIDs = new uint256[](len); + uint256[] memory amounts = new uint256[](len); + uint256[] memory values = new uint256[](len); + + { + uint256[] memory _valuesCache = _values; + uint256 swapValue = _valuesCache[len]; + _valuesCache[len] = _valuesCache[0]; + _valuesCache[0] = swapValue; + + for (uint256 i; i < len;) { + _notMaxItem(maxIndex[_typeID]); + + typeIDs[i] = _typeID; + fromIDs[i] = _tokenID; + toIDs[i] = _typeID + ++maxIndex[_typeID]; + amounts[i] = 1; + values[i] = _valuesCache[i]; + + unchecked { + ++i; + } + } + } + + _beforeUnitTransfer(_msgSender(), owners[_tokenID], fromIDs, toIDs, values, ""); + + for (uint256 i; i < len;) { + valueLeft -= values[i]; + + tokenValues[toIDs[i]] = values[i]; + + unchecked { + ++i; + } + } + + tokenValues[_tokenID] = valueLeft; + + _mintBatch(_account, toIDs, amounts, ""); + + emit BatchValueTransfer(typeIDs, fromIDs, toIDs, values); + } + + /** + * @dev Merges the units of multiple tokens into a single token. + * @param _account The address of the account that will receive the merged token. + * @param _fractionIDs An array of token IDs to merge. + * @dev This function merges the units of multiple tokens into a single token. + * @dev The `_fractionIDs` array specifies the IDs of the tokens to merge. + * @dev The function checks that the length of the `_fractionIDs` array is between 2 and `FRACTION_LIMIT`. + * @dev The function then calculates the total value of the merged token by summing the values of the tokens to be + * merged. + * @dev The `tokenValues` mapping is updated with the total value of the merged token. + * @dev The tokens to be merged are burned except the last one that receives all the units. + * @dev A `BatchValueTransfer` event is emitted to indicate that the tokens have been merged into a single token. + */ + function _mergeTokensUnits(address _account, uint256[] memory _fractionIDs) internal { + if (_fractionIDs.length > FRACTION_LIMIT || _fractionIDs.length < 2) { + revert Errors.ArraySize(); + } + uint256 len = _fractionIDs.length - 1; + + uint256 _typeID = getBaseType(_fractionIDs[0]); + uint256 target = _fractionIDs[len]; + + uint256 _totalValue; + uint256[] memory typeIDs = new uint256[](len); + uint256[] memory fromIDs = new uint256[](len); + uint256[] memory toIDs = new uint256[](len); + uint256[] memory values = new uint256[](len); + uint256[] memory amounts = new uint256[](len); + + { + for (uint256 i; i < len;) { + uint256 _fractionID = _fractionIDs[i]; + typeIDs[i] = _typeID; + fromIDs[i] = _fractionID; + toIDs[i] = target; + amounts[i] = 1; + values[i] = tokenValues[_fractionID]; + + if (_account == address(0) || owners[_fractionID] != _account || owners[target] != _account) { + revert Errors.NotAllowed(); + } + + unchecked { + ++i; + } + } + } + + _beforeUnitTransfer(_msgSender(), _account, fromIDs, toIDs, values, ""); + + for (uint256 i; i < len;) { + _totalValue += values[i]; + + delete tokenValues[fromIDs[i]]; + unchecked { + ++i; + } + } + + tokenValues[target] += _totalValue; + + _burnBatch(_account, fromIDs, amounts); + emit BatchValueTransfer(typeIDs, fromIDs, toIDs, values); + } + + /** + * @dev Burns a single token and emits a `ValueTransfer` event with a value of 0. + * @param _account The address of the account that owns the token to burn. + * @param _tokenID The ID of the token to burn. + * @dev This function burns a single token with the specified ID and emits a `ValueTransfer` event `toTokenID` 0. + * @dev The function checks that the caller is the owner of the token or is approved to burn the token on behalf of + * the owner. + * @dev The function then deletes the token from the `tokenValues` mapping and calls the `_burn` function to burn + * the token. + */ + function _burnToken(address _account, uint256 _tokenID) internal { + if (_account != _msgSender() && !isApprovedForAll(_account, _msgSender())) revert Errors.NotApprovedOrOwner(); + + uint256 value = tokenValues[_tokenID]; + + delete tokenValues[_tokenID]; + + _burn(_account, _tokenID, 1); + emit ValueTransfer(getBaseType(_tokenID), _tokenID, 0, value); + } + + /** + * @dev Burns multiple tokens and emits a `BatchValueTransfer` event with a value of 0 for each token burned. + * @param _account The address of the account that owns the tokens to burn. + * @param _tokenIDs An array of token IDs to burn. + * @dev This function burns multiple tokens with the specified IDs and emits a `BatchValueTransfer` event. + * @dev The function checks that the caller is the owner of the tokens or is approved to burn the tokens on behalf + * of the owner. + * @dev The function then deletes the tokens from the `tokenValues` mapping and calls the `_burnBatch` function to + * burn the tokens. + * @dev Finally, the function emits a `BatchValueTransfer` event with a value of 1 and `toTokenIDs` as 0 for each + * token burned to indicate that the tokens have been burned. + */ + function _batchBurnToken(address _account, uint256[] memory _tokenIDs) internal { + if (_account != _msgSender() && !isApprovedForAll(_account, _msgSender())) revert Errors.NotApprovedOrOwner(); + + uint256 len = _tokenIDs.length; + + // ERC115 requires values + uint256[] memory claimIDs = new uint256[](len); + uint256[] memory toTokens = new uint256[](len); + uint256[] memory claimUnits = new uint256[](len); + uint256[] memory values = new uint256[](len); + + for (uint256 i; i < len; i++) { + uint256 _tokenId = _tokenIDs[i]; + uint256 value = tokenValues[_tokenId]; + + delete tokenValues[_tokenId]; + + claimIDs[i] = getBaseType(_tokenId); + claimUnits[i] = value; + values[i] = 1; + } + + _burnBatch(_account, _tokenIDs, values); + emit BatchValueTransfer(claimIDs, _tokenIDs, toTokens, claimUnits); + } + + /// TRANSFERS + + // The following functions are overrides required by Solidity. + /** + * @dev Called after a token transfer has been completed. + * @param operator The address of the operator performing the transfer. + * @param from The address of the sender of the tokens. + * @param to The address of the recipient of the tokens. + * @param ids An array of token IDs that were transferred. + * @param amounts An array of token amounts that were transferred. + * @param data Additional data that was passed along with the transfer. + * @dev This function updates the `owners` mapping to reflect the new owner of each token that was transferred. + */ + function _afterTokenTransfer( + address operator, + address from, + address to, + uint256[] memory ids, + uint256[] memory amounts, + bytes memory data + ) internal virtual override { + super._afterTokenTransfer(operator, from, to, ids, amounts, data); + + uint256 len = ids.length; + + for (uint256 i; i < len;) { + owners[ids[i]] = to; + unchecked { + ++i; + } + } + } + + /** + * @dev Called before a batch of tokens is transferred. + * @param {operator} The address of the operator performing the transfer. + * @param from The address of the sender of the tokens. + * @param fromIDs An array of token IDs that are being transferred. + * @param toIDs An array of token IDs that the tokens are being transferred to. + * @param {values} An array of token amounts that are being transferred. + * @param {data} Additional data that was passed along with the transfer. + * @dev This function checks that the transfer is allowed by verifying that the sender is approved to transfer the + * tokens and that the tokens being transferred are of the same base type. + */ + function _beforeUnitTransfer( + address, /*operator*/ + address from, + uint256[] memory fromIDs, + uint256[] memory toIDs, + uint256[] memory, /*values*/ + bytes memory /*data*/ + ) internal virtual { + uint256 len = fromIDs.length; + if (from != _msgSender() && !isApprovedForAll(from, _msgSender())) revert Errors.NotApprovedOrOwner(); + + for (uint256 i; i < len;) { + uint256 _from = fromIDs[i]; + uint256 _to = toIDs[i]; + + if (isBaseType(_from)) revert Errors.NotAllowed(); + if (getBaseType(_from) != getBaseType(_to)) revert Errors.TypeMismatch(); + unchecked { + ++i; + } + } + } + + /// METADATA + + /** + * @dev Returns the metadata URI for a given token ID. + * @param tokenID The ID of the token to retrieve the metadata URI for. + * @return _uri The metadata URI for the specified token ID. + * @dev This function retrieves the metadata URI for the specified token ID by calling the `uri` function of the + * `ERC1155URIStorageUpgradeable` contract. + * @dev The metadata URI is a string that points to a JSON file containing information about the token, such as its + * name, symbol, and image. + * @dev This function always returns the URI for the basetype so that it's managed in one place. + */ + function uri(uint256 tokenID) + public + view + virtual + override(ERC1155Upgradeable, ERC1155URIStorageUpgradeable) + returns (string memory _uri) + { + // All tokens share the same metadata at the moment + _uri = ERC1155URIStorageUpgradeable.uri(getBaseType(tokenID)); + } + + /// UTILS + + /** + * @dev Checks if the specified token ID is below the maximum item index. + * @param tokenID The ID of the token to check. + * @dev This function checks if the specified token ID is below the maximum item index by converting the token ID to + * a `uint128` value and incrementing it. + * @dev If the token ID is greater than or equal to the maximum item index, the function will revert with an error. + */ + function _notMaxItem(uint256 tokenID) private pure { + uint128 _count = uint128(tokenID); + ++_count; + } + + /** + * @dev Checks if the specified token ID is below the maximum type index. + * @param tokenID The ID of the token to check. + * @dev This function checks if the specified token ID is below the maximum type index by shifting the token ID + * right by 128 bits to get the type ID and converting it to a `uint128` value. + * @dev If the type ID is greater than or equal to the maximum type index, the function will revert with an error. + */ + function _notMaxType(uint256 tokenID) private pure { + uint128 _count = uint128(tokenID >> 128); + ++_count; + } + + /** + * @dev Calculates the sum of the elements of an array. + * @param array The array of uint256 values to sum. + * @return sum The sum of the elements of the array. + * @dev This function calculates the sum of the elements of the specified array by iterating over the array and + * adding each element to a running total. + * @dev If an element in the array is 0, the function will revert with an error. + */ + function _getSum(uint256[] memory array) internal pure returns (uint256 sum) { + uint256 len = array.length; + for (uint256 i; i < len;) { + if (array[i] == 0) revert Errors.NotAllowed(); + sum += array[i]; + unchecked { + ++i; + } + } + } + + /** + * @dev Returns an array containing a single element. + * @param element The element to include in the array. + * @return An array containing a single element. + * @dev This function returns an array containing a single element by creating a new array with a length of 1 and + * setting the first element to the specified value. + */ + function _getSingletonArray(uint256 element) private pure returns (uint256[] memory) { + uint256[] memory array = new uint256[](1); + array[0] = element; + + return array; + } + + // UUPS PROXY + + /// @dev see { openzeppelin-contracts-upgradeable/contracts/proxy/utils/UUPSUpgradeable.sol } + function _authorizeUpgrade(address newImplementation) internal virtual override onlyOwner { + // solhint-disable-previous-line no-empty-blocks + } + + /** + * @dev This empty reserved space is put in place to allow future versions to add new + * variables without shifting down storage in the inheritance chain. + * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps + * Assuming 30 available slots (slots cost space, cost gas) + * 1. typeCounter + * 2. owners + * 3. creators + * 4. tokenValues + * 5. maxIndex + */ + uint256[25] private __gap; +} + +// File src/protocol/HypercertMinter.sol + +// Original license: SPDX_License_Identifier: MIT +pragma solidity 0.8.17; + +/// @title Contract for managing hypercert claims and whitelists +/// @author bitbeckers +/// @notice Implementation of the HypercertTokenInterface using { SemiFungible1155 } as underlying token. +/// @notice This contract supports whitelisted minting via { AllowlistMinter }. +/// @dev Wrapper contract to expose and chain functions. +contract HypercertMinter is IHypercertToken, SemiFungible1155, AllowlistMinter, PausableUpgradeable { + // solhint-disable-next-line const-name-snakecase + string public constant name = "HypercertMinter"; + /// @dev from typeID to a transfer policy + mapping(uint256 => TransferRestrictions) internal typeRestrictions; + + /// INIT + + /// @dev see { openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol } + /// @custom:oz-upgrades-unsafe-allow constructor + constructor() { + _disableInitializers(); + } + + /// @dev see { openzeppelin-contracts-upgradeable/contracts/proxy/utils/Initializable.sol } + function initialize() public virtual initializer { + __SemiFungible1155_init(); + __Pausable_init(); + } + + /// EXTERNAL + + /// @notice Mint a semi-fungible token for the impact claim referenced via `uri` + /// @dev see {IHypercertToken} + function mintClaim(address account, uint256 units, string memory _uri, TransferRestrictions restrictions) + external + override + whenNotPaused + { + // This enables us to release this restriction in the future + if (msg.sender != account) revert Errors.NotAllowed(); + uint256 claimID = _mintNewTypeWithToken(account, units, _uri); + typeRestrictions[claimID] = restrictions; + emit ClaimStored(claimID, _uri, units); + } + + /// @notice Mint semi-fungible tokens for the impact claim referenced via `uri` + /// @dev see {IHypercertToken} + function mintClaimWithFractions( + address account, + uint256 units, + uint256[] calldata fractions, + string memory _uri, + TransferRestrictions restrictions + ) external override whenNotPaused { + // This enables us to release this restriction in the future + if (msg.sender != account) revert Errors.NotAllowed(); + //Using sum to compare units and fractions (sanity check) + if (_getSum(fractions) != units) revert Errors.Invalid(); + + uint256 claimID = _mintNewTypeWithTokens(account, fractions, _uri); + typeRestrictions[claimID] = restrictions; + emit ClaimStored(claimID, _uri, units); + } + + /// @notice Mint a semi-fungible token representing a fraction of the claim + /// @dev Calls AllowlistMinter to verify `proof`. + /// @dev Mints the `amount` of units for the hypercert stored under `claimID` + function mintClaimFromAllowlist(address account, bytes32[] calldata proof, uint256 claimID, uint256 units) + external + whenNotPaused + { + _processClaim(proof, claimID, units); + _mintToken(account, claimID, units); + } + + /// @notice Mint semi-fungible tokens representing a fraction of the claims in `claimIDs` + /// @dev Calls AllowlistMinter to verify `proofs`. + /// @dev Mints the `amount` of units for the hypercert stored under `claimIDs` + function batchMintClaimsFromAllowlists( + address account, + bytes32[][] calldata proofs, + uint256[] calldata claimIDs, + uint256[] calldata units + ) external whenNotPaused { + uint256 len = claimIDs.length; + for (uint256 i; i < len;) { + _processClaim(proofs[i], claimIDs[i], units[i]); + unchecked { + ++i; + } + } + _batchMintTokens(account, claimIDs, units); + } + + /// @notice Register a claim and the whitelist for minting token(s) belonging to that claim + /// @dev Calls SemiFungible1155 to store the claim referenced in `uri` with amount of `units` + /// @dev Calls AllowlistMinter to store the `merkleRoot` as proof to authorize claims + function createAllowlist( + address account, + uint256 units, + bytes32 merkleRoot, + string memory _uri, + TransferRestrictions restrictions + ) external whenNotPaused { + uint256 claimID = _createTokenType(account, units, _uri); + _createAllowlist(claimID, merkleRoot, units); + typeRestrictions[claimID] = restrictions; + emit ClaimStored(claimID, _uri, units); + } + + /// @notice Split a claimtokens value into parts with summed value equal to the original + /// @dev see {IHypercertToken} + function splitFraction(address _account, uint256 _tokenID, uint256[] calldata _newFractions) + external + whenNotPaused + { + _splitTokenUnits(_account, _tokenID, _newFractions); + } + + /// @notice Merge the value of tokens belonging to the same claim + /// @dev see {IHypercertToken} + function mergeFractions(address _account, uint256[] calldata _fractionIDs) external whenNotPaused { + _mergeTokensUnits(_account, _fractionIDs); + } + + /// @notice Burn a claimtoken + /// @dev see {IHypercertToken} + function burnFraction(address _account, uint256 _tokenID) external whenNotPaused { + _burnToken(_account, _tokenID); + } + + /// @notice Burn a claimtoken + /// @dev see {IHypercertToken} + function batchBurnFraction(address _account, uint256[] memory _tokenIDs) external whenNotPaused { + _batchBurnToken(_account, _tokenIDs); + } + + /// @notice Burn a claimtoken; override is needed to update units/values + /// @dev see {ERC1155Burnable} + function burn(address account, uint256 id, uint256 /*value*/ ) public override whenNotPaused { + _burnToken(account, id); + } + + /// @notice Batch burn claimtokens; override is needed to update units/values + /// @dev see {ERC1155Burnable} + function burnBatch(address account, uint256[] memory ids, uint256[] memory /*values*/ ) + public + override + whenNotPaused + { + _batchBurnToken(account, ids); + } + + /// @dev see {IHypercertToken} + function unitsOf(uint256 tokenID) external view override returns (uint256 units) { + units = _unitsOf(tokenID); + } + + /// @dev see {IHypercertToken} + function unitsOf(address account, uint256 tokenID) external view override returns (uint256 units) { + units = _unitsOf(account, tokenID); + } + + /// PAUSABLE + + function pause() external onlyOwner { + _pause(); + } + + function unpause() external onlyOwner { + _unpause(); + } + + /// METADATA + + /// @dev see { IHypercertMetadata} + function uri(uint256 tokenID) + public + view + override(IHypercertToken, SemiFungible1155) + returns (string memory _uri) + { + _uri = SemiFungible1155.uri(tokenID); + } + + /// TRANSFER RESTRICTIONS + + function readTransferRestriction(uint256 tokenID) external view returns (string memory) { + TransferRestrictions temp = typeRestrictions[getBaseType(tokenID)]; + if (temp == TransferRestrictions.AllowAll) return "AllowAll"; + if (temp == TransferRestrictions.DisallowAll) return "DisallowAll"; + if (temp == TransferRestrictions.FromCreatorOnly) return "FromCreatorOnly"; + return ""; + } + + /// INTERNAL + + /// @dev see { openzeppelin-contracts-upgradeable/contracts/proxy/utils/UUPSUpgradeable.sol } + function _authorizeUpgrade(address newImplementation) internal virtual override onlyOwner { + // solhint-disable-previous-line no-empty-blocks + } + + function _beforeTokenTransfer( + address operator, + address from, + address to, + uint256[] memory ids, + uint256[] memory amounts, + bytes memory data + ) internal virtual override { + super._beforeTokenTransfer(operator, from, to, ids, amounts, data); + + // By-pass transfer restrictions for minting and burning + if (from == address(0)) { + // Minting + return; + } else if (to == address(0)) { + // Burning + return; + } + + // Transfer case, where to and from are non-zero + uint256 len = ids.length; + for (uint256 i; i < len;) { + uint256 typeID = getBaseType(ids[i]); + TransferRestrictions policy = typeRestrictions[typeID]; + if (policy == TransferRestrictions.DisallowAll) { + revert Errors.TransfersNotAllowed(); + } else if (policy == TransferRestrictions.FromCreatorOnly && from != creators[typeID]) { + revert Errors.TransfersNotAllowed(); + } + unchecked { + ++i; + } + } + } + + /** + * @dev See {IERC165-supportsInterface}. + */ + function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { + return interfaceId == type(IHypercertToken).interfaceId || super.supportsInterface(interfaceId); + } + + /** + * @dev This empty reserved space is put in place to allow future versions to add new + * variables without shifting down storage in the inheritance chain. + * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps + * Assuming 30 available slots (slots cost space, cost gas) + * 1. typeRestrictions + */ + uint256[29] private __gap; +} diff --git a/contracts/src/deployments/deployments-protocol.json b/contracts/src/deployments/deployments-protocol.json index de246bf..46ac08a 100644 --- a/contracts/src/deployments/deployments-protocol.json +++ b/contracts/src/deployments/deployments-protocol.json @@ -30,5 +30,9 @@ "314159": { "HypercertMinterUUPS": "0x822F17A9A5EeCFd66dBAFf7946a8071C265D1d07", "HypercertMinterImplementation": "0xc6FbcFE16D5eBFEd21aCe224C49C94dE49046A04" + }, + "314": { + "HypercertMinterUUPS": "0xc756B203cA9e13BAB3a93F1dA756bb19ac3C395b", + "HypercertMinterImplementation": "0xC2d179166bc9dbB00A03686a5b17eCe2224c2704 " } } diff --git a/contracts/src/index.ts b/contracts/src/index.ts index 7b04b75..f8b5157 100644 --- a/contracts/src/index.ts +++ b/contracts/src/index.ts @@ -89,6 +89,9 @@ const deployments = { 314159: { ...DEPLOYMENTS.protocol["314159"], }, + 314: { + ...DEPLOYMENTS.protocol["314"], + }, } as Record; const asDeployedChain = (chainId: string | number) => { diff --git a/contracts/tasks/config.ts b/contracts/tasks/config.ts index aa452b6..69bd9df 100644 --- a/contracts/tasks/config.ts +++ b/contracts/tasks/config.ts @@ -1,15 +1,18 @@ -// Define supported networks and their tokens -type NetworkTokens = { - [network: string]: { - tokens: { - symbol: string; - address: string; - faucetUrl?: string; - }[]; - }; -}; +import { chainIds } from "../config/ChainConfig"; + +interface Token { + symbol: string; + address: string; + faucetUrl?: string; +} + +interface NetworkConfig { + tokens: Token[]; + adminAccount: string; + feeRecipient: string; +} -const NETWORK_TOKENS: NetworkTokens = { +const NETWORK_CONFIGS: Record = { localhost: { tokens: [ { symbol: "ETH", address: "0x0000000000000000000000000000000000000000" }, @@ -17,9 +20,13 @@ const NETWORK_TOKENS: NetworkTokens = { { symbol: "DAI", address: "0x779877A7B0D9E8603169DdbD7836e478b4624789" }, { symbol: "USDC", address: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238" }, ], + adminAccount: "0x4f37308832c6eFE5A74737955cBa96257d76De17", + feeRecipient: "0x4f37308832c6eFE5A74737955cBa96257d76De17", }, hardhat: { tokens: [{ symbol: "ETH", address: "0x0000000000000000000000000000000000000000" }], + adminAccount: "0x4f37308832c6eFE5A74737955cBa96257d76De17", + feeRecipient: "0x4f37308832c6eFE5A74737955cBa96257d76De17", }, sepolia: { tokens: [ @@ -36,6 +43,8 @@ const NETWORK_TOKENS: NetworkTokens = { faucetUrl: "https://faucet.circle.com/", }, ], + adminAccount: "0x4f37308832c6eFE5A74737955cBa96257d76De17", + feeRecipient: "0x4f37308832c6eFE5A74737955cBa96257d76De17", }, "optimism-mainnet": { tokens: [ @@ -44,6 +53,8 @@ const NETWORK_TOKENS: NetworkTokens = { { symbol: "DAI", address: "0xda10009cbd5d07dd0cecc66161fc93d7c9000da1" }, { symbol: "USDC", address: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85" }, ], + adminAccount: "0x560adA72a80b4707e493cA8c3B7B7528930E7Be5", + feeRecipient: "0xE7C4531ad8828794904D332a12702beC8ff1A498", }, "base-sepolia": { tokens: [ @@ -52,6 +63,8 @@ const NETWORK_TOKENS: NetworkTokens = { { symbol: "DAI", address: "0xE4aB69C077896252FAFBD49EFD26B5D171A32410" }, { symbol: "USDC", address: "0x036CbD53842c5426634e7929541eC2318f3dCF7e" }, ], + adminAccount: "0xA2Cb9D926b090577AD45fC0F40C753BF369B82Ff", + feeRecipient: "0xe518aED97D9d45174a06bB8EF663B4fB51330725", }, "arb-sepolia": { tokens: [ @@ -60,6 +73,8 @@ const NETWORK_TOKENS: NetworkTokens = { { symbol: "DAI", address: "0xb1D4538B4571d411F07960EF2838Ce337FE1E80E" }, { symbol: "USDC", address: "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d" }, ], + adminAccount: "0x5d36971451AE593685Cab8815d644f9B4B66Ec99", + feeRecipient: "0x5d36971451AE593685Cab8815d644f9B4B66Ec99", }, arbitrumOne: { tokens: [ @@ -68,9 +83,10 @@ const NETWORK_TOKENS: NetworkTokens = { { symbol: "DAI", address: "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1" }, { symbol: "USDC", address: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831" }, ], + adminAccount: "0x14ae502FEF3843fF3a1735B3209D39B320130af9", + feeRecipient: "0xE7C4531ad8828794904D332a12702beC8ff1A498", }, "celo-mainnet": { - //https://docs.celo.org/cel2/fee-currencies tokens: [ { symbol: "CELO", @@ -89,67 +105,43 @@ const NETWORK_TOKENS: NetworkTokens = { address: "0x48065fbBE25f71C9282ddf5e1cD6D6A887483D5e", }, ], + adminAccount: "0x14ae502FEF3843fF3a1735B3209D39B320130af9", + feeRecipient: "0xE7C4531ad8828794904D332a12702beC8ff1A498", + }, + "filecoin-mainnet": { + tokens: [], + adminAccount: "0xee849dAf7A549DC0Fd89658F570d21b61ae88bf8", + feeRecipient: "0xF2403Fdb4cEb27Be833153d8c4f5885a81c3a7B4", }, }; -// New helper functions -export const getSupportedTokens = (network: string) => { - const networkConfig = NETWORK_TOKENS[network]; - if (!networkConfig) { +// Helper function to get network config +function getNetworkConfig(network: keyof typeof chainIds): NetworkConfig { + const config = NETWORK_CONFIGS[network]; + if (!config) { throw new Error(`Network "${network}" is not supported`); } - return networkConfig.tokens; -}; + return config; +} -export const getTokenAddress = (network: string, symbol: string) => { +// Public API +export function getSupportedTokens(network: keyof typeof chainIds): Token[] { + return getNetworkConfig(network).tokens; +} + +export function getTokenAddress(network: keyof typeof chainIds, symbol: string): string { const tokens = getSupportedTokens(network); const token = tokens.find((t) => t.symbol === symbol); if (!token) { throw new Error(`Token "${symbol}" is not supported on network "${network}"`); } return token.address; -}; +} -const ADMIN_ACCOUNT: { [key: string]: string } = { - localhost: "0x4f37308832c6eFE5A74737955cBa96257d76De17", - hardhat: "0x4f37308832c6eFE5A74737955cBa96257d76De17", - sepolia: "0x4f37308832c6eFE5A74737955cBa96257d76De17", - "base-sepolia": "0xA2Cb9D926b090577AD45fC0F40C753BF369B82Ff", - "optimism-mainnet": "0x560adA72a80b4707e493cA8c3B7B7528930E7Be5", - "celo-mainnet": "0x14ae502FEF3843fF3a1735B3209D39B320130af9", - base: "0x14ae502FEF3843fF3a1735B3209D39B320130af9", - arbitrumOne: "0x14ae502FEF3843fF3a1735B3209D39B320130af9", - "arb-sepolia": "0x5d36971451AE593685Cab8815d644f9B4B66Ec99", -}; +export function getAdminAccount(network: keyof typeof chainIds): string { + return getNetworkConfig(network).adminAccount; +} -export const getAdminAccount = (network: string): string => { - const account = ADMIN_ACCOUNT[network]; - - if (!account || account === null || account.trim() === "") { - throw new Error(`Admin account for network "${network}" is not defined, null, or empty.`); - } - - return account; -}; - -const FEE_RECIPIENT: { [key: string]: string } = { - localhost: "0x4f37308832c6eFE5A74737955cBa96257d76De17", - hardhat: "0x4f37308832c6eFE5A74737955cBa96257d76De17", - sepolia: "0x4f37308832c6eFE5A74737955cBa96257d76De17", - "base-sepolia": "0xe518aED97D9d45174a06bB8EF663B4fB51330725", - "optimism-mainnet": "0xE7C4531ad8828794904D332a12702beC8ff1A498", - "celo-mainnet": "0xE7C4531ad8828794904D332a12702beC8ff1A498", - base: "0xE7C4531ad8828794904D332a12702beC8ff1A498", - arbitrumOne: "0xE7C4531ad8828794904D332a12702beC8ff1A498", - "arb-sepolia": "0x5d36971451AE593685Cab8815d644f9B4B66Ec99", -}; - -export const getFeeRecipient = (network: string): string => { - const recipient = FEE_RECIPIENT[network]; - - if (!recipient || recipient === null || recipient.trim() === "") { - throw new Error(`Fee recipient for network "${network}" is not defined, null, or empty.`); - } - - return recipient; -}; +export function getFeeRecipient(network: keyof typeof chainIds): string { + return getNetworkConfig(network).feeRecipient; +} diff --git a/contracts/tasks/deploy-minter.ts b/contracts/tasks/deploy-minter.ts index 3252f45..c5cc17a 100644 --- a/contracts/tasks/deploy-minter.ts +++ b/contracts/tasks/deploy-minter.ts @@ -32,7 +32,7 @@ task("deploy-minter", "Deploy contracts and verify") } if (network.name !== "hardhat" && network.name !== "localhost") { - if (network.name !== "filecoinCalibration") { + if (!network.name.startsWith("filecoin")) { try { const code = await hypercertMinter.instance?.provider.getCode(address); if (code === "0x") { @@ -50,7 +50,7 @@ task("deploy-minter", "Deploy contracts and verify") } console.error(errorMessage); } - } else if (network.name === "filecoinCalibration") { + } else { try { const code = await hypercertMinter.instance?.provider.getCode(address); if (code === "0x") { @@ -67,8 +67,6 @@ task("deploy-minter", "Deploy contracts and verify") } console.error(errorMessage); } - } else { - console.log("No verification for this network"); } } }); diff --git a/contracts/tsconfig.json b/contracts/tsconfig.json index 638bfc4..b7018de 100644 --- a/contracts/tsconfig.json +++ b/contracts/tsconfig.json @@ -17,7 +17,7 @@ "target": "ES2022", "outDir": "dist" }, - "include": ["./tasks", "./test", "./src", "./hardhat.config.cjs", "./types"], + "include": ["./tasks", "./test", "./src", "./hardhat.config.cjs", "./types", "./utils", "./config"], "ts-node": { "experimentalResolver": true, "files": true diff --git a/contracts/utils/requireEnv.ts b/contracts/utils/requireEnv.ts new file mode 100644 index 0000000..d9ef78d --- /dev/null +++ b/contracts/utils/requireEnv.ts @@ -0,0 +1,13 @@ +/** + * Ensures that a required environment variable exists and returns its value + * @param value The environment variable value + * @param identifier The name of the environment variable + * @returns The environment variable value + * @throws Error if the environment variable is not set + */ +export function requireEnv(value: string | undefined, identifier: string): string { + if (!value) { + throw new Error(`Required env var ${identifier} does not exist`); + } + return value; +} diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index a66fa7d..32c91bb 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -23,19 +23,13 @@ importers: contracts: dependencies: - '@starboardventures/hardhat-verify': - specifier: ^1.0.1 - version: 1.0.1(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)) - '@tenderly/hardhat-tenderly': - specifier: ^2.3.0 - version: 2.3.0(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(@swc/core@1.6.3)(@types/node@18.18.7)(bufferutil@4.0.8)(encoding@0.1.13)(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10) hardhat: specifier: ^2.22.18 - version: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10) + version: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10) devDependencies: '@chainlink/contracts': specifier: ^0.8.0 - version: 0.8.0(bufferutil@4.0.8)(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10) + version: 0.8.0(bufferutil@4.0.8)(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10) '@commitlint/cli': specifier: ^17.1.2 version: 17.8.1(@swc/core@1.6.3) @@ -47,76 +41,76 @@ importers: version: 3.4.0 '@nomicfoundation/hardhat-ethers': specifier: ^3.0.8 - version: 3.0.8(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)) + version: 3.0.8(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)) '@nomicfoundation/hardhat-toolbox': specifier: ^5.0.0 - version: 5.0.0(@nomicfoundation/hardhat-chai-matchers@2.0.7(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(chai@4.5.0)(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-ignition-ethers@0.15.4(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-ignition@0.15.5(@nomicfoundation/hardhat-verify@2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(bufferutil@4.0.8)(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10))(@nomicfoundation/ignition-core@0.15.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-network-helpers@1.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-verify@2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(@typechain/ethers-v6@0.4.3(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.5.3))(typescript@5.5.3))(@typechain/hardhat@9.1.0(@typechain/ethers-v6@0.4.3(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.5.3))(typescript@5.5.3))(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.5.3)))(@types/chai@4.3.11)(@types/mocha@9.1.0)(@types/node@18.18.7)(chai@4.5.0)(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat-gas-reporter@1.0.9(bufferutil@4.0.8)(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))(solidity-coverage@0.8.5(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typechain@8.3.2(typescript@5.5.3))(typescript@5.5.3) + version: 5.0.0(@nomicfoundation/hardhat-chai-matchers@2.0.7(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(chai@4.5.0)(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-ignition-ethers@0.15.4(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-ignition@0.15.5(@nomicfoundation/hardhat-verify@2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(bufferutil@4.0.8)(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10))(@nomicfoundation/ignition-core@0.15.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-network-helpers@1.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-verify@2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(@typechain/ethers-v6@0.4.3(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.7.3))(typescript@5.7.3))(@typechain/hardhat@9.1.0(@typechain/ethers-v6@0.4.3(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.7.3))(typescript@5.7.3))(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.7.3)))(@types/chai@4.3.11)(@types/mocha@9.1.0)(@types/node@18.19.71)(chai@4.5.0)(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat-gas-reporter@1.0.9(bufferutil@4.0.8)(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10))(solidity-coverage@0.8.5(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typechain@8.3.2(typescript@5.7.3))(typescript@5.7.3) '@nomicfoundation/hardhat-viem': specifier: ^2.0.6 - version: 2.0.6(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))(typescript@5.5.3)(viem@2.19.7(bufferutil@4.0.8)(typescript@5.5.3)(utf-8-validate@5.0.10)(zod@3.23.8))(zod@3.23.8) + version: 2.0.6(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10))(typescript@5.7.3)(viem@2.22.10(bufferutil@4.0.8)(typescript@5.7.3)(utf-8-validate@5.0.10)(zod@3.23.8))(zod@3.23.8) '@openzeppelin/contracts': specifier: ^4.9.3 version: 4.9.3 '@openzeppelin/hardhat-upgrades': specifier: 3.9.0 - version: 3.9.0(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-verify@2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(encoding@0.1.13)(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)) + version: 3.9.0(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-verify@2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(encoding@0.1.13)(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)) '@primitivefi/hardhat-dodoc': specifier: ^0.2.3 - version: 0.2.3(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))(squirrelly@8.0.8) + version: 0.2.3(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10))(squirrelly@8.0.8) '@rollup/plugin-commonjs': specifier: ^24.0.1 - version: 24.1.0(rollup@4.6.1) + version: 24.1.0(rollup@4.31.0) '@rollup/plugin-json': - specifier: ^6.0.0 - version: 6.0.1(rollup@4.6.1) + specifier: ^6.1.0 + version: 6.1.0(rollup@4.31.0) '@rollup/plugin-node-resolve': - specifier: ^15.0.1 - version: 15.2.3(rollup@4.6.1) + specifier: ^15.3.1 + version: 15.3.1(rollup@4.31.0) '@trivago/prettier-plugin-sort-imports': specifier: ^3.3.0 version: 3.4.0(prettier@2.8.8) '@typechain/hardhat': specifier: ^9.1.0 - version: 9.1.0(@typechain/ethers-v6@0.4.3(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.5.3))(typescript@5.5.3))(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.5.3)) + version: 9.1.0(@typechain/ethers-v6@0.4.3(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.7.3))(typescript@5.7.3))(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.7.3)) '@types/node': - specifier: ^18.18.1 - version: 18.18.7 + specifier: ^18.19.71 + version: 18.19.71 '@typescript-eslint/eslint-plugin': - specifier: ^7.12.0 - version: 7.12.0(@typescript-eslint/parser@7.12.0(eslint@8.52.0)(typescript@5.5.3))(eslint@8.52.0)(typescript@5.5.3) + specifier: ^7.18.0 + version: 7.18.0(@typescript-eslint/parser@7.18.0(eslint@8.57.1)(typescript@5.7.3))(eslint@8.57.1)(typescript@5.7.3) '@typescript-eslint/parser': - specifier: ^7.12.0 - version: 7.12.0(eslint@8.52.0)(typescript@5.5.3) + specifier: ^7.18.0 + version: 7.18.0(eslint@8.57.1)(typescript@5.7.3) chai: specifier: ^4.5.0 version: 4.5.0 commitizen: - specifier: ^4.2.5 - version: 4.3.0(typescript@5.5.3) + specifier: ^4.3.1 + version: 4.3.1(typescript@5.7.3) cross-env: specifier: ^7.0.3 version: 7.0.3 cz-conventional-changelog: specifier: ^3.3.0 - version: 3.3.0(typescript@5.5.3) + version: 3.3.0(typescript@5.7.3) dotenv: - specifier: ^16.0.2 - version: 16.3.1 + specifier: ^16.4.7 + version: 16.4.7 eslint: - specifier: ^8.23.1 - version: 8.52.0 + specifier: ^8.57.1 + version: 8.57.1 eslint-config-prettier: specifier: ^8.5.0 - version: 8.10.0(eslint@8.52.0) + version: 8.10.0(eslint@8.57.1) ethers: - specifier: ^6.8.0 - version: 6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) + specifier: ^6.13.5 + version: 6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10) hardhat-abi-exporter: specifier: ^2.10.1 - version: 2.10.1(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)) + version: 2.10.1(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)) hardhat-preprocessor: specifier: ^0.1.5 - version: 0.1.5(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)) + version: 0.1.5(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)) husky: specifier: ^8.0.1 version: 8.0.3 @@ -127,56 +121,53 @@ importers: specifier: ^2.8.8 version: 2.8.8 prettier-plugin-solidity: - specifier: ^1.1.3 - version: 1.1.3(prettier@2.8.8) + specifier: ^1.4.2 + version: 1.4.2(prettier@2.8.8) rimraf: - specifier: ^5.0.5 - version: 5.0.5 + specifier: ^5.0.10 + version: 5.0.10 rollup: - specifier: ^4.0.2 - version: 4.6.1 + specifier: ^4.31.0 + version: 4.31.0 rollup-plugin-auto-external: specifier: ^2.0.0 - version: 2.0.0(rollup@4.6.1) + version: 2.0.0(rollup@4.31.0) rollup-plugin-dts: specifier: ^6.1.1 - version: 6.1.1(rollup@4.6.1)(typescript@5.5.3) + version: 6.1.1(rollup@4.31.0)(typescript@5.7.3) rollup-plugin-esbuild: - specifier: ^6.1.0 - version: 6.1.0(esbuild@0.21.5)(rollup@4.6.1) + specifier: ^6.1.1 + version: 6.1.1(esbuild@0.21.5)(rollup@4.31.0) rollup-plugin-node-polyfills: specifier: ^0.2.1 version: 0.2.1 rollup-plugin-swc3: specifier: ^0.11.2 - version: 0.11.2(@swc/core@1.6.3)(rollup@4.6.1) + version: 0.11.2(@swc/core@1.6.3)(rollup@4.31.0) shx: specifier: ^0.3.4 version: 0.3.4 solhint: specifier: ^3.6.2 - version: 3.6.2(typescript@5.5.3) + version: 3.6.2(typescript@5.7.3) solhint-plugin-prettier: specifier: ^0.0.5 - version: 0.0.5(prettier-plugin-solidity@1.1.3(prettier@2.8.8))(prettier@2.8.8) + version: 0.0.5(prettier-plugin-solidity@1.4.2(prettier@2.8.8))(prettier@2.8.8) solmate: - specifier: ^6.2.0 - version: 6.2.0 + specifier: ^6.8.0 + version: 6.8.0 ts-node: - specifier: ^10.9.1 - version: 10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3) + specifier: ^10.9.2 + version: 10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3) typechain: specifier: ^8.3.2 - version: 8.3.2(typescript@5.5.3) + version: 8.3.2(typescript@5.7.3) typescript: - specifier: ^5.5.3 - version: 5.5.3 + specifier: ^5.7.3 + version: 5.7.3 viem: - specifier: ^2.19.7 - version: 2.19.7(bufferutil@4.0.8)(typescript@5.5.3)(utf-8-validate@5.0.10)(zod@3.23.8) - xdeployer: - specifier: ^2.1.13 - version: 2.1.13(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)) + specifier: ^2.22.10 + version: 2.22.10(bufferutil@4.0.8)(typescript@5.7.3)(utf-8-validate@5.0.10)(zod@3.23.8) packages: @@ -184,12 +175,12 @@ packages: resolution: {integrity: sha512-1Yjs2SvM8TflER/OD3cOjhWWOZb58A2t7wpE2S9XfBYTiIl+XFhQG2bjy4Pu1I+EAlCNUzRDYDdFwFYUKvXcIA==} engines: {node: '>=0.10.0'} - '@adraffy/ens-normalize@1.10.0': - resolution: {integrity: sha512-nA9XHtlAkYfJxY7bce8DcN7eKxWWCWkU+1GR9d+U6MbNpfwQp8TI7vqOsBsMcHoT4mBu2kypKoSKnghEzOOq5Q==} - '@adraffy/ens-normalize@1.10.1': resolution: {integrity: sha512-96Z2IP3mYmF1Xg2cDm8f1gWGf/HUVedQ3FMifV4kG/PQ4yEP51xDtRAEfhVNt5f/uzpNkZHwWQuUcu6D6K+Ekw==} + '@adraffy/ens-normalize@1.11.0': + resolution: {integrity: sha512-/3DDPKHqqIqxUULp8yP4zODUY1i+2xvVWsv8A79xGWdCAG+8sb0hRh0Rk2QyOJUnnbyPUAZYcpBuRe3nS2OIUg==} + '@ampproject/remapping@2.2.1': resolution: {integrity: sha512-lFMjJTrFL3j7L9yBxwYfCq2k6qqwHyzuUl/XBnif78PWTJYyL/dfowQHWE3sp6U6ZzqWiiIZnpTMO96zhkjwtg==} engines: {node: '>=6.0.0'} @@ -438,10 +429,6 @@ packages: '@chainlink/contracts@0.8.0': resolution: {integrity: sha512-nUv1Uxw5Mn92wgLs2bgPYmo8hpdQ3s9jB/lcbdU0LmNOVu0hbfmouVnqwRLa28Ll50q6GczUA+eO0ikNIKLZsA==} - '@colors/colors@1.5.0': - resolution: {integrity: sha512-ooWCrlZP11i8GImSjTHYHLkvFDP48nS4+204nGb1RiX/WXYHmJA2III9/e2DWVabCESdW7hBAEzHRqUn9OUVvQ==} - engines: {node: '>=0.1.90'} - '@commitlint/cli@17.8.1': resolution: {integrity: sha512-ay+WbzQesE0Rv4EQKfNbSMiJJ12KdKTDzIt0tcK4k11FdsWmtwP0Kp1NWMOUswfIWo6Eb7p7Ln721Nx9FLNBjg==} engines: {node: '>=v14'} @@ -679,16 +666,22 @@ packages: peerDependencies: eslint: ^6.0.0 || ^7.0.0 || >=8.0.0 + '@eslint-community/eslint-utils@4.4.1': + resolution: {integrity: sha512-s3O3waFUrMV8P/XaF/+ZTp1X9XBZW1a4B97ZnjQF2KYWaFD2A8KyFBsrsfSjEmjn3RGWAIuvlneuZm3CUK3jbA==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + peerDependencies: + eslint: ^6.0.0 || ^7.0.0 || >=8.0.0 + '@eslint-community/regexpp@4.10.0': resolution: {integrity: sha512-Cu96Sd2By9mCNTx2iyKOmq10v22jUVQv0lQnlGNy16oE9589yE+QADPbrMGCkA51cKZSg3Pu/aTJVTGfL/qjUA==} engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0} - '@eslint/eslintrc@2.1.2': - resolution: {integrity: sha512-+wvgpDsrB1YqAMdEUCcnTlpfVBH7Vqn6A/NT3D8WVXFIaKMlErPIZT3oCIAVCOtarRpMtelZLqJeU3t7WY6X6g==} + '@eslint/eslintrc@2.1.4': + resolution: {integrity: sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - '@eslint/js@8.52.0': - resolution: {integrity: sha512-mjZVbpaeMZludF2fsWLD0Z9gCref1Tk4i9+wddjRvpUNqqcndPkBD09N/Mapey0b3jaXbLm2kICwFv2E64QinA==} + '@eslint/js@8.57.1': + resolution: {integrity: sha512-d9zaMRSTIKDLhctzH12MtXvJKSSUhaHcjV+2Z+GK+EEY7XKpP5yR4x+N3TAcHTcu963nIr+TMcCb4DBCYX1z6Q==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} '@eth-optimism/contracts@0.5.40': @@ -805,19 +798,25 @@ packages: resolution: {integrity: sha512-JUFJad5lv7jxj926GPgymrWQxxjPYuJNiNjNMzqT+HiuP6Vl3dk5xzG+8sTX96np0ZAluvaMzPsjhHZ5rNuNQQ==} engines: {node: '>=14'} + '@fastify/busboy@2.1.1': + resolution: {integrity: sha512-vBZP4NlzfOlerQTnba4aqZoMhE/a9HY7HRqoOPaETQcSQuWEIyZMHGfVu6w9wGtGK5fED5qRs2DteVCjOH60sA==} + engines: {node: '>=14'} + '@fastify/deepmerge@1.3.0': resolution: {integrity: sha512-J8TOSBq3SoZbDhM9+R/u77hP93gz/rajSA+K2kGyijPpORPWUXHUpTaleoj+92As0S9uPRP7Oi8IqMf0u+ro6A==} - '@humanwhocodes/config-array@0.11.13': - resolution: {integrity: sha512-JSBDMiDKSzQVngfRjOdFXgFfklaXI4K9nLF49Auh21lmBWRLIK3+xTErTWD4KU54pb6coM6ESE7Awz/FNU3zgQ==} + '@humanwhocodes/config-array@0.13.0': + resolution: {integrity: sha512-DZLEEqFWQFiyK6h5YIeynKx7JlvCYWL0cImfSRXZ9l4Sg2efkFGTuFf6vzXjK1cq6IYkU+Eg/JizXw+TD2vRNw==} engines: {node: '>=10.10.0'} + deprecated: Use @eslint/config-array instead '@humanwhocodes/module-importer@1.0.1': resolution: {integrity: sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==} engines: {node: '>=12.22'} - '@humanwhocodes/object-schema@2.0.1': - resolution: {integrity: sha512-dvuCeX5fC9dXgJn9t+X5atfmgQAzUOWqS1254Gh0m6i8wKd10ebXkfNKiRK+1GWi/yTvvLDHpoxLr0xxxeslWw==} + '@humanwhocodes/object-schema@2.0.3': + resolution: {integrity: sha512-93zYdMES/c1D69yZiKDBj0V24vqNzB/koF26KPaagAfd3P/4gUlh3Dys5ogAK+Exi9QyzlD8x/08Zt7wIKcDcA==} + deprecated: Use @eslint/object-schema instead '@isaacs/cliui@8.0.2': resolution: {integrity: sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==} @@ -852,22 +851,19 @@ packages: resolution: {integrity: sha512-tghyZKLHZjcdlDqCA3gNZmLeR0XvOE9U1qoQO9ohyAZT6Pya+H9vkBPcsyXytmYLNgVoin7CKCmweo/R43V+tQ==} engines: {node: '>=12.0.0'} - '@noble/curves@1.1.0': - resolution: {integrity: sha512-091oBExgENk/kGj3AZmtBDMpxQPDtxQABR2B9lb1JbVTs6ytdzZNwvhxQ4MWasRNEzlbEH8jCWFCwhF/Obj5AA==} - '@noble/curves@1.2.0': resolution: {integrity: sha512-oYclrNgRaM9SsBUBVbb8M6DTV7ZHRTKugureoYEncY5c65HOmRzvSiTE3y5CYaPYJA/GVkrhXEoF0M3Ya9PMnw==} - '@noble/curves@1.4.0': - resolution: {integrity: sha512-p+4cb332SFCrReJkCYe8Xzm0OWi4Jji5jVdIZRL/PmacmDkFNw6MrrV+gGpiPxLHbV+zKFRywUWbaseT+tZRXg==} + '@noble/curves@1.4.2': + resolution: {integrity: sha512-TavHr8qycMChk8UwMld0ZDRvatedkzWfH8IiaeGCfymOP5i0hSCozz9vHOL0nkwk7HRMlFnAiKpS2jrUmSybcw==} + + '@noble/curves@1.7.0': + resolution: {integrity: sha512-UTMhXK9SeDhFJVrHeUJ5uZlI6ajXg10O6Ddocf9S6GjbSBVZsJo88HzKwXznNfGpMTRDyJkqMjNDPYgf0qFWnw==} + engines: {node: ^14.21.3 || >=16} '@noble/hashes@1.2.0': resolution: {integrity: sha512-FZfhjEDbT5GRswV3C6uvLPHMiVD6lQBmpoX5+eSiPaMTXte/IKqI5dykDxzZB/WBeK/CDuQRBWarPdi3FNY2zQ==} - '@noble/hashes@1.3.1': - resolution: {integrity: sha512-EbqwksQwz9xDRGfDST86whPBgM65E0OH/pCgqW0GBVzO22bNE+NuIbeTb714+IfSjU3aRk47EUvXIb5bTsenKA==} - engines: {node: '>= 16'} - '@noble/hashes@1.3.2': resolution: {integrity: sha512-MVC8EAQp7MvEcm30KWENFjgR+Mkmf+D189XJTkFIlwohU5hcBbn1ZkKq7KVTi2Hme3PMGF390DaL52beVrIihQ==} engines: {node: '>= 16'} @@ -876,6 +872,18 @@ packages: resolution: {integrity: sha512-V1JJ1WTRUqHHrOSh597hURcMqVKVGL/ea3kv0gSnEdsEZ0/+VyPghM1lMNGc00z7CIQorSvbKpuJkxvuHbvdbg==} engines: {node: '>= 16'} + '@noble/hashes@1.6.0': + resolution: {integrity: sha512-YUULf0Uk4/mAA89w+k3+yUYh6NrEvxZa5T6SY3wlMvE2chHkxFUUIDI8/XW1QSC357iA5pSnqt7XEhvFOqmDyQ==} + engines: {node: ^14.21.3 || >=16} + + '@noble/hashes@1.6.1': + resolution: {integrity: sha512-pq5D8h10hHBjyqX+cfBm0i8JUXJ0UhczFc4r74zbuT9XgewFo2E3J1cOaGtdZynILNmQ685YWGzGE1Zv6io50w==} + engines: {node: ^14.21.3 || >=16} + + '@noble/hashes@1.7.1': + resolution: {integrity: sha512-B8XBPsn4vT/KJAGqDzbwztd+6Yte3P4V7iafm24bxgDe/mlRuK6xmWPuCNrKt2vDafZ8MfJLlchDG/vYafQEjQ==} + engines: {node: ^14.21.3 || >=16} + '@noble/secp256k1@1.7.1': resolution: {integrity: sha512-hOUk6AyBFmqVrv7k5WAw/LpszxVbj9gGN4JRkIX52fdFAj1UA61KXmZDvqVEm+pOyec3+fIeZB02LYa/pWOArw==} @@ -1019,48 +1027,8 @@ packages: '@nomicfoundation/ignition-core@0.15.5': resolution: {integrity: sha512-FgvuoIXhakRSP524JzNQ4BviyzBBKpsFaOWubPZ4XACLT4/7vGqlJ/7DIn0D2NL2anQ2qs98/BNBY9WccXUX1Q==} - '@nomicfoundation/ignition-ui@0.15.5': - resolution: {integrity: sha512-ZcE4rIn10qKahR4OqS8rl8NM2Fbg2QYiBXgMgj74ZI0++LlCcZgB5HyaBbX+lsnKHjTXtjYD3b+2mtg7jFbAMQ==} - - '@nomicfoundation/slang-darwin-arm64@0.15.1': - resolution: {integrity: sha512-taPHlCUNNztQZJze9OlZFK9cZH8Ut4Ih4QJQo5CKebXx9vWOUtmSBfKv/M2P8hiV/iL7Q5sPwR7HY9uZYnb49Q==} - engines: {node: '>= 10'} - - '@nomicfoundation/slang-darwin-x64@0.15.1': - resolution: {integrity: sha512-kgZh5KQe/UcbFqn1EpyrvBuT8E6I1kWSgGPtO25t90zAqFv23sMUPdn7wLpMjngkD+quIIgrzQGUtupS5YYEig==} - engines: {node: '>= 10'} - - '@nomicfoundation/slang-linux-arm64-gnu@0.15.1': - resolution: {integrity: sha512-Iw8mepaccKRWllPU9l+hoe88LN9fScC0Px3nFeNQy26qk1ueO0tjovP1dhTvmGwHUxacOYPqhQTUn7Iu0oxNoQ==} - engines: {node: '>= 10'} - - '@nomicfoundation/slang-linux-arm64-musl@0.15.1': - resolution: {integrity: sha512-zcesdQZwRgrT7ND+3TZUjRK/uGF20EfhEfCg8ZMhrb4Q7XaK1JvtHazIs03TV8Jcs30TPkEXks8Qi0Zdfy4RuA==} - engines: {node: '>= 10'} - - '@nomicfoundation/slang-linux-x64-gnu@0.15.1': - resolution: {integrity: sha512-FSmAnzKm58TFIwx4r/wOZtqfDx0nI6AfvnOh8kLDF5OxpWW3r0q9fq8lyaUReg9C/ZgCZRBn+m5WGrNKCZcvPQ==} - engines: {node: '>= 10'} - - '@nomicfoundation/slang-linux-x64-musl@0.15.1': - resolution: {integrity: sha512-hnoA/dgeHQ8aS0SReABYkxf0d/Q6DdaKsaYv6ev21wyQA7TROxT1X3nekECLGu1GYLML8pzvD9vyAMBRKOkkyg==} - engines: {node: '>= 10'} - - '@nomicfoundation/slang-win32-arm64-msvc@0.15.1': - resolution: {integrity: sha512-2H0chHQ4uTh4l4UxN5fIVHR5mKaL5mfYTID6kxxxv2+KAh68EpYWwxLlkS5So90R2WcuPvFvTVKLm/uRo4h4dg==} - engines: {node: '>= 10'} - - '@nomicfoundation/slang-win32-ia32-msvc@0.15.1': - resolution: {integrity: sha512-CVZWBnbpFlVBg/m7bsiw70jY3p9TGH9vxq0vLEEJ56yK+QPosxPrKMcADojtGjIOjWjPSZ+lCoo5ilnW0a249g==} - engines: {node: '>= 10'} - - '@nomicfoundation/slang-win32-x64-msvc@0.15.1': - resolution: {integrity: sha512-cyER8M1fdBTzIfihy55d4LGGlN/eQxDqfRUTXgJf1VvNR98tRB0Q3nBfyh5PK2yP98B4lMt3RJYDqTQu+dOVDA==} - engines: {node: '>= 10'} - - '@nomicfoundation/slang@0.15.1': - resolution: {integrity: sha512-th7nxRWRXf583uHpWUCd8U7BYxIqJX2f3oZLff/mlPkqIr45pD2hLT/o00eCjrBIR8N7vybUULZg1CeThGNk7g==} - engines: {node: '>= 10'} + '@nomicfoundation/ignition-ui@0.15.9': + resolution: {integrity: sha512-8lzbT7gpJ5PoowPQDQilkwdyqBviUKDMoHp/5rhgnwG1bDslnCS+Lxuo6s9R2akWu9LtEL14dNyqQb6WsURTag==} '@nomicfoundation/slang@0.18.3': resolution: {integrity: sha512-YqAWgckqbHM0/CZxi9Nlf4hjk9wUNLC9ngWCWBiqMxPIZmzsVKYuChdlrfeBPQyvQQBoOhbx+7C1005kLVQDZQ==} @@ -1071,12 +1039,20 @@ packages: cpu: [arm64] os: [darwin] + '@nomicfoundation/solidity-analyzer-darwin-arm64@0.1.2': + resolution: {integrity: sha512-JaqcWPDZENCvm++lFFGjrDd8mxtf+CtLd2MiXvMNTBD33dContTZ9TWETwNFwg7JTJT5Q9HEecH7FA+HTSsIUw==} + engines: {node: '>= 12'} + '@nomicfoundation/solidity-analyzer-darwin-x64@0.1.1': resolution: {integrity: sha512-XhQG4BaJE6cIbjAVtzGOGbK3sn1BO9W29uhk9J8y8fZF1DYz0Doj8QDMfpMu+A6TjPDs61lbsmeYodIDnfveSA==} engines: {node: '>= 10'} cpu: [x64] os: [darwin] + '@nomicfoundation/solidity-analyzer-darwin-x64@0.1.2': + resolution: {integrity: sha512-fZNmVztrSXC03e9RONBT+CiksSeYcxI1wlzqyr0L7hsQlK1fzV+f04g2JtQ1c/Fe74ZwdV6aQBdd6Uwl1052sw==} + engines: {node: '>= 12'} + '@nomicfoundation/solidity-analyzer-freebsd-x64@0.1.1': resolution: {integrity: sha512-GHF1VKRdHW3G8CndkwdaeLkVBi5A9u2jwtlS7SLhBc8b5U/GcoL39Q+1CSO3hYqePNP+eV5YI7Zgm0ea6kMHoA==} engines: {node: '>= 10'} @@ -1089,24 +1065,40 @@ packages: cpu: [arm64] os: [linux] + '@nomicfoundation/solidity-analyzer-linux-arm64-gnu@0.1.2': + resolution: {integrity: sha512-3d54oc+9ZVBuB6nbp8wHylk4xh0N0Gc+bk+/uJae+rUgbOBwQSfuGIbAZt1wBXs5REkSmynEGcqx6DutoK0tPA==} + engines: {node: '>= 12'} + '@nomicfoundation/solidity-analyzer-linux-arm64-musl@0.1.1': resolution: {integrity: sha512-WJ3CE5Oek25OGE3WwzK7oaopY8xMw9Lhb0mlYuJl/maZVo+WtP36XoQTb7bW/i8aAdHW5Z+BqrHMux23pvxG3w==} engines: {node: '>= 10'} cpu: [arm64] os: [linux] + '@nomicfoundation/solidity-analyzer-linux-arm64-musl@0.1.2': + resolution: {integrity: sha512-iDJfR2qf55vgsg7BtJa7iPiFAsYf2d0Tv/0B+vhtnI16+wfQeTbP7teookbGvAo0eJo7aLLm0xfS/GTkvHIucA==} + engines: {node: '>= 12'} + '@nomicfoundation/solidity-analyzer-linux-x64-gnu@0.1.1': resolution: {integrity: sha512-5WN7leSr5fkUBBjE4f3wKENUy9HQStu7HmWqbtknfXkkil+eNWiBV275IOlpXku7v3uLsXTOKpnnGHJYI2qsdA==} engines: {node: '>= 10'} cpu: [x64] os: [linux] + '@nomicfoundation/solidity-analyzer-linux-x64-gnu@0.1.2': + resolution: {integrity: sha512-9dlHMAt5/2cpWyuJ9fQNOUXFB/vgSFORg1jpjX1Mh9hJ/MfZXlDdHQ+DpFCs32Zk5pxRBb07yGvSHk9/fezL+g==} + engines: {node: '>= 12'} + '@nomicfoundation/solidity-analyzer-linux-x64-musl@0.1.1': resolution: {integrity: sha512-KdYMkJOq0SYPQMmErv/63CwGwMm5XHenEna9X9aB8mQmhDBrYrlAOSsIPgFCUSL0hjxE3xHP65/EPXR/InD2+w==} engines: {node: '>= 10'} cpu: [x64] os: [linux] + '@nomicfoundation/solidity-analyzer-linux-x64-musl@0.1.2': + resolution: {integrity: sha512-GzzVeeJob3lfrSlDKQw2bRJ8rBf6mEYaWY+gW0JnTDHINA0s2gPR4km5RLIj1xeZZOYz4zRw+AEeYgLRqB2NXg==} + engines: {node: '>= 12'} + '@nomicfoundation/solidity-analyzer-win32-arm64-msvc@0.1.1': resolution: {integrity: sha512-VFZASBfl4qiBYwW5xeY20exWhmv6ww9sWu/krWSesv3q5hA0o1JuzmPHR4LPN6SUZj5vcqci0O6JOL8BPw+APg==} engines: {node: '>= 10'} @@ -1125,10 +1117,18 @@ packages: cpu: [x64] os: [win32] + '@nomicfoundation/solidity-analyzer-win32-x64-msvc@0.1.2': + resolution: {integrity: sha512-Fdjli4DCcFHb4Zgsz0uEJXZ2K7VEO+w5KVv7HmT7WO10iODdU9csC2az4jrhEsRtiR9Gfd74FlG0NYlw1BMdyA==} + engines: {node: '>= 12'} + '@nomicfoundation/solidity-analyzer@0.1.1': resolution: {integrity: sha512-1LMtXj1puAxyFusBgUIy5pZk3073cNXYnXUpuNKFghHbIit/xZgbk0AokpUADbNm3gyD6bFWl3LRFh3dhVdREg==} engines: {node: '>= 12'} + '@nomicfoundation/solidity-analyzer@0.1.2': + resolution: {integrity: sha512-q4n32/FNKIhQ3zQGGw5CvPF6GTvDCpYwIf7bEY/dZTZbgfDsHyjJwURxUJf3VQuuJj+fDIFl4+KkBVbw4Ef6jA==} + engines: {node: '>= 12'} + '@openzeppelin/contracts-upgradeable@4.7.3': resolution: {integrity: sha512-+wuegAMaLcZnLCJIvrVUDzA9z/Wp93f0Dla/4jJvIhijRrPabjQbZe6fWiECLaJyfn5ci9fqf9vTw3xpQOad2A==} @@ -1162,10 +1162,6 @@ packages: '@nomicfoundation/hardhat-verify': optional: true - '@openzeppelin/upgrades-core@1.35.1': - resolution: {integrity: sha512-FzbOzMrrNtXpL+DoM6jtOGZOvUdp6F4KTsb0niqfrd2BxMecL9fUA0aupi09p1Of+9BELcYozX/Gt7tr91Z2TA==} - hasBin: true - '@openzeppelin/upgrades-core@1.41.0': resolution: {integrity: sha512-+oryinqZnxkiZvg7bWqWX4Ki/CNwVUZEqC6Elpi5PQoahpL3/6Sq9xjIozD5AiI2O61h8JHQ+A//5NtczyavJw==} hasBin: true @@ -1189,8 +1185,8 @@ packages: rollup: optional: true - '@rollup/plugin-json@6.0.1': - resolution: {integrity: sha512-RgVfl5hWMkxN1h/uZj8FVESvPuBJ/uf6ly6GTj0GONnkfoBN5KC0MSz+PN2OLDgYXMhtG0mWpTrkiOjoxAIevw==} + '@rollup/plugin-json@6.1.0': + resolution: {integrity: sha512-EGI2te5ENk1coGeADSIwZ7G2Q8CJS2sF120T7jLw4xFw9n7wIOXHo+kIYRAoVpJAN+kmqZSoO3Fp4JtoNF4ReA==} engines: {node: '>=14.0.0'} peerDependencies: rollup: ^1.20.0||^2.0.0||^3.0.0||^4.0.0 @@ -1198,8 +1194,8 @@ packages: rollup: optional: true - '@rollup/plugin-node-resolve@15.2.3': - resolution: {integrity: sha512-j/lym8nf5E21LwBT4Df1VD6hRO2L2iwUeUmP7litikRsVp1H6NWx20NEp0Y7su+7XGc476GnXXc4kFeZNGmaSQ==} + '@rollup/plugin-node-resolve@15.3.1': + resolution: {integrity: sha512-tgg6b91pAybXHJQMAAwW9VuWBO6Thi+q7BCNARLwSqlmsHz0XYURtGvh/AuwSADXSI4h/2uHbs7s4FzlZDGSGA==} engines: {node: '>=14.0.0'} peerDependencies: rollup: ^2.78.0||^3.0.0||^4.0.0 @@ -1225,87 +1221,137 @@ packages: rollup: optional: true - '@rollup/rollup-android-arm-eabi@4.6.1': - resolution: {integrity: sha512-0WQ0ouLejaUCRsL93GD4uft3rOmB8qoQMU05Kb8CmMtMBe7XUDLAltxVZI1q6byNqEtU7N1ZX1Vw5lIpgulLQA==} + '@rollup/pluginutils@5.1.4': + resolution: {integrity: sha512-USm05zrsFxYLPdWWq+K3STlWiT/3ELn3RcV5hJMghpeAIhxfsUIg6mt12CBJBInWMV4VneoV7SfGv8xIwo2qNQ==} + engines: {node: '>=14.0.0'} + peerDependencies: + rollup: ^1.20.0||^2.0.0||^3.0.0||^4.0.0 + peerDependenciesMeta: + rollup: + optional: true + + '@rollup/rollup-android-arm-eabi@4.31.0': + resolution: {integrity: sha512-9NrR4033uCbUBRgvLcBrJofa2KY9DzxL2UKZ1/4xA/mnTNyhZCWBuD8X3tPm1n4KxcgaraOYgrFKSgwjASfmlA==} cpu: [arm] os: [android] - '@rollup/rollup-android-arm64@4.6.1': - resolution: {integrity: sha512-1TKm25Rn20vr5aTGGZqo6E4mzPicCUD79k17EgTLAsXc1zysyi4xXKACfUbwyANEPAEIxkzwue6JZ+stYzWUTA==} + '@rollup/rollup-android-arm64@4.31.0': + resolution: {integrity: sha512-iBbODqT86YBFHajxxF8ebj2hwKm1k8PTBQSojSt3d1FFt1gN+xf4CowE47iN0vOSdnd+5ierMHBbu/rHc7nq5g==} cpu: [arm64] os: [android] - '@rollup/rollup-darwin-arm64@4.6.1': - resolution: {integrity: sha512-cEXJQY/ZqMACb+nxzDeX9IPLAg7S94xouJJCNVE5BJM8JUEP4HeTF+ti3cmxWeSJo+5D+o8Tc0UAWUkfENdeyw==} + '@rollup/rollup-darwin-arm64@4.31.0': + resolution: {integrity: sha512-WHIZfXgVBX30SWuTMhlHPXTyN20AXrLH4TEeH/D0Bolvx9PjgZnn4H677PlSGvU6MKNsjCQJYczkpvBbrBnG6g==} cpu: [arm64] os: [darwin] - '@rollup/rollup-darwin-x64@4.6.1': - resolution: {integrity: sha512-LoSU9Xu56isrkV2jLldcKspJ7sSXmZWkAxg7sW/RfF7GS4F5/v4EiqKSMCFbZtDu2Nc1gxxFdQdKwkKS4rwxNg==} + '@rollup/rollup-darwin-x64@4.31.0': + resolution: {integrity: sha512-hrWL7uQacTEF8gdrQAqcDy9xllQ0w0zuL1wk1HV8wKGSGbKPVjVUv/DEwT2+Asabf8Dh/As+IvfdU+H8hhzrQQ==} cpu: [x64] os: [darwin] - '@rollup/rollup-linux-arm-gnueabihf@4.6.1': - resolution: {integrity: sha512-EfI3hzYAy5vFNDqpXsNxXcgRDcFHUWSx5nnRSCKwXuQlI5J9dD84g2Usw81n3FLBNsGCegKGwwTVsSKK9cooSQ==} + '@rollup/rollup-freebsd-arm64@4.31.0': + resolution: {integrity: sha512-S2oCsZ4hJviG1QjPY1h6sVJLBI6ekBeAEssYKad1soRFv3SocsQCzX6cwnk6fID6UQQACTjeIMB+hyYrFacRew==} + cpu: [arm64] + os: [freebsd] + + '@rollup/rollup-freebsd-x64@4.31.0': + resolution: {integrity: sha512-pCANqpynRS4Jirn4IKZH4tnm2+2CqCNLKD7gAdEjzdLGbH1iO0zouHz4mxqg0uEMpO030ejJ0aA6e1PJo2xrPA==} + cpu: [x64] + os: [freebsd] + + '@rollup/rollup-linux-arm-gnueabihf@4.31.0': + resolution: {integrity: sha512-0O8ViX+QcBd3ZmGlcFTnYXZKGbFu09EhgD27tgTdGnkcYXLat4KIsBBQeKLR2xZDCXdIBAlWLkiXE1+rJpCxFw==} + cpu: [arm] + os: [linux] + + '@rollup/rollup-linux-arm-musleabihf@4.31.0': + resolution: {integrity: sha512-w5IzG0wTVv7B0/SwDnMYmbr2uERQp999q8FMkKG1I+j8hpPX2BYFjWe69xbhbP6J9h2gId/7ogesl9hwblFwwg==} cpu: [arm] os: [linux] - '@rollup/rollup-linux-arm64-gnu@4.6.1': - resolution: {integrity: sha512-9lhc4UZstsegbNLhH0Zu6TqvDfmhGzuCWtcTFXY10VjLLUe4Mr0Ye2L3rrtHaDd/J5+tFMEuo5LTCSCMXWfUKw==} + '@rollup/rollup-linux-arm64-gnu@4.31.0': + resolution: {integrity: sha512-JyFFshbN5xwy6fulZ8B/8qOqENRmDdEkcIMF0Zz+RsfamEW+Zabl5jAb0IozP/8UKnJ7g2FtZZPEUIAlUSX8cA==} cpu: [arm64] os: [linux] - '@rollup/rollup-linux-arm64-musl@4.6.1': - resolution: {integrity: sha512-FfoOK1yP5ksX3wwZ4Zk1NgyGHZyuRhf99j64I5oEmirV8EFT7+OhUZEnP+x17lcP/QHJNWGsoJwrz4PJ9fBEXw==} + '@rollup/rollup-linux-arm64-musl@4.31.0': + resolution: {integrity: sha512-kpQXQ0UPFeMPmPYksiBL9WS/BDiQEjRGMfklVIsA0Sng347H8W2iexch+IEwaR7OVSKtr2ZFxggt11zVIlZ25g==} cpu: [arm64] os: [linux] - '@rollup/rollup-linux-x64-gnu@4.6.1': - resolution: {integrity: sha512-DNGZvZDO5YF7jN5fX8ZqmGLjZEXIJRdJEdTFMhiyXqyXubBa0WVLDWSNlQ5JR2PNgDbEV1VQowhVRUh+74D+RA==} + '@rollup/rollup-linux-loongarch64-gnu@4.31.0': + resolution: {integrity: sha512-pMlxLjt60iQTzt9iBb3jZphFIl55a70wexvo8p+vVFK+7ifTRookdoXX3bOsRdmfD+OKnMozKO6XM4zR0sHRrQ==} + cpu: [loong64] + os: [linux] + + '@rollup/rollup-linux-powerpc64le-gnu@4.31.0': + resolution: {integrity: sha512-D7TXT7I/uKEuWiRkEFbed1UUYZwcJDU4vZQdPTcepK7ecPhzKOYk4Er2YR4uHKme4qDeIh6N3XrLfpuM7vzRWQ==} + cpu: [ppc64] + os: [linux] + + '@rollup/rollup-linux-riscv64-gnu@4.31.0': + resolution: {integrity: sha512-wal2Tc8O5lMBtoePLBYRKj2CImUCJ4UNGJlLwspx7QApYny7K1cUYlzQ/4IGQBLmm+y0RS7dwc3TDO/pmcneTw==} + cpu: [riscv64] + os: [linux] + + '@rollup/rollup-linux-s390x-gnu@4.31.0': + resolution: {integrity: sha512-O1o5EUI0+RRMkK9wiTVpk2tyzXdXefHtRTIjBbmFREmNMy7pFeYXCFGbhKFwISA3UOExlo5GGUuuj3oMKdK6JQ==} + cpu: [s390x] + os: [linux] + + '@rollup/rollup-linux-x64-gnu@4.31.0': + resolution: {integrity: sha512-zSoHl356vKnNxwOWnLd60ixHNPRBglxpv2g7q0Cd3Pmr561gf0HiAcUBRL3S1vPqRC17Zo2CX/9cPkqTIiai1g==} cpu: [x64] os: [linux] - '@rollup/rollup-linux-x64-musl@4.6.1': - resolution: {integrity: sha512-RkJVNVRM+piYy87HrKmhbexCHg3A6Z6MU0W9GHnJwBQNBeyhCJG9KDce4SAMdicQnpURggSvtbGo9xAWOfSvIQ==} + '@rollup/rollup-linux-x64-musl@4.31.0': + resolution: {integrity: sha512-ypB/HMtcSGhKUQNiFwqgdclWNRrAYDH8iMYH4etw/ZlGwiTVxBz2tDrGRrPlfZu6QjXwtd+C3Zib5pFqID97ZA==} cpu: [x64] os: [linux] - '@rollup/rollup-win32-arm64-msvc@4.6.1': - resolution: {integrity: sha512-v2FVT6xfnnmTe3W9bJXl6r5KwJglMK/iRlkKiIFfO6ysKs0rDgz7Cwwf3tjldxQUrHL9INT/1r4VA0n9L/F1vQ==} + '@rollup/rollup-win32-arm64-msvc@4.31.0': + resolution: {integrity: sha512-JuhN2xdI/m8Hr+aVO3vspO7OQfUFO6bKLIRTAy0U15vmWjnZDLrEgCZ2s6+scAYaQVpYSh9tZtRijApw9IXyMw==} cpu: [arm64] os: [win32] - '@rollup/rollup-win32-ia32-msvc@4.6.1': - resolution: {integrity: sha512-YEeOjxRyEjqcWphH9dyLbzgkF8wZSKAKUkldRY6dgNR5oKs2LZazqGB41cWJ4Iqqcy9/zqYgmzBkRoVz3Q9MLw==} + '@rollup/rollup-win32-ia32-msvc@4.31.0': + resolution: {integrity: sha512-U1xZZXYkvdf5MIWmftU8wrM5PPXzyaY1nGCI4KI4BFfoZxHamsIe+BtnPLIvvPykvQWlVbqUXdLa4aJUuilwLQ==} cpu: [ia32] os: [win32] - '@rollup/rollup-win32-x64-msvc@4.6.1': - resolution: {integrity: sha512-0zfTlFAIhgz8V2G8STq8toAjsYYA6eci1hnXuyOTUFnymrtJwnS6uGKiv3v5UrPZkBlamLvrLV2iiaeqCKzb0A==} + '@rollup/rollup-win32-x64-msvc@4.31.0': + resolution: {integrity: sha512-ul8rnCsUumNln5YWwz0ted2ZHFhzhRRnkpBZ+YRuHoRAlUji9KChpOUOndY7uykrPEPXVbHLlsdo6v5yXo/TXw==} cpu: [x64] os: [win32] '@scure/base@1.1.7': resolution: {integrity: sha512-PPNYBslrLNNUQ/Yad37MHYsNQtK67EhWb6WtSvNLLPo7SdVZgkUjD6Dg+5On7zNwmskf8OX7I7Nx5oN+MIWE0g==} + '@scure/base@1.1.9': + resolution: {integrity: sha512-8YKhl8GHiNI/pU2VMaofa2Tor7PJRAjwQLBBuilkJ9L5+13yVbC7JO/wS7piioAvPSwR3JKM1IJ/u4xQzbcXKg==} + + '@scure/base@1.2.4': + resolution: {integrity: sha512-5Yy9czTO47mqz+/J8GM6GIId4umdCk1wc1q8rKERQulIoc8VP9pzDcghv10Tl2E7R96ZUx/PhND3ESYUQX8NuQ==} + '@scure/bip32@1.1.5': resolution: {integrity: sha512-XyNh1rB0SkEqd3tXcXMi+Xe1fvg+kUIcoRIEujP1Jgv7DqW2r9lg3Ah0NkFaCs9sTkQAQA8kw7xiRXzENi9Rtw==} - '@scure/bip32@1.3.1': - resolution: {integrity: sha512-osvveYtyzdEVbt3OfwwXFr4P2iVBL5u1Q3q4ONBfDY/UpOuXmOlbgwc1xECEboY8wIays8Yt6onaWMUdUbfl0A==} - '@scure/bip32@1.4.0': resolution: {integrity: sha512-sVUpc0Vq3tXCkDGYVWGIZTRfnvu8LoTDaev7vbwh0omSvVORONr960MQWdKqJDCReIEmTj3PAr73O3aoxz7OPg==} + '@scure/bip32@1.6.0': + resolution: {integrity: sha512-82q1QfklrUUdXJzjuRU7iG7D7XiFx5PHYVS0+oeNKhyDLT7WPqs6pBcM2W5ZdwOwKCwoE1Vy1se+DHjcXwCYnA==} + '@scure/bip39@1.1.1': resolution: {integrity: sha512-t+wDck2rVkh65Hmv280fYdVdY25J9YeEUIgn2LG1WM6gxFkGzcksoDiUkWVpVp3Oex9xGC68JU2dSbUfwZ2jPg==} - '@scure/bip39@1.2.1': - resolution: {integrity: sha512-Z3/Fsz1yr904dduJD0NpiyRHhRYHdcnyh73FZWiV+/qhWi83wNJ3NWolYqCEN+ZWsUz2TWwajJggcRE9r1zUYg==} - '@scure/bip39@1.3.0': resolution: {integrity: sha512-disdg7gHuTDZtY+ZdkmLpPCk7fxZSu3gBiEGuoC1XYxv9cGx3Z6cpTggCgW6odSOOIXCiDjuGejW+aJKCY/pIQ==} + '@scure/bip39@1.5.0': + resolution: {integrity: sha512-Dop+ASYhnrwm9+HA/HwXg7j2ZqM6yk2fyLWb5znexjctFY3+E+eU8cIWI0Pql0Qx4hPZCijlGq4OL71g+Uz30A==} + '@sentry/core@5.30.0': resolution: {integrity: sha512-TmfrII8w1PQZSZgPpUESqjB+jC6MvZJZdLtE/0hZ+SrnKhW3x5WlYLvTXZpcWePYBku7rl2wn1RZu6uT0qCTeg==} engines: {node: '>=6'} @@ -1536,10 +1582,11 @@ packages: '@solidity-parser/parser@0.16.1': resolution: {integrity: sha512-PdhRFNhbTtu3x8Axm0uYpqOy/lODYQK+MlYSgqIsq2L8SFYEHJPHNUiOTAJbDGzNjjr1/n9AcIayxafR/fWmYw==} - '@starboardventures/hardhat-verify@1.0.1': - resolution: {integrity: sha512-/FO3wMmUSrL8PsYwuxA233+3iwLzmjI2z39MiZCgki0uJXtDELhO9YXDI9qoUR2jHxvHiBa1gKd/ZIpC9tpuKw==} - peerDependencies: - hardhat: ^2.0.0 + '@solidity-parser/parser@0.16.2': + resolution: {integrity: sha512-PI9NfoA3P8XK2VBkK5oIfRgKDsicwDZfkVq9ZTBCQYGOP1N2owgY2dyLGyU5/J/hQs8KRk55kdmvTLjy3Mu3vg==} + + '@solidity-parser/parser@0.19.0': + resolution: {integrity: sha512-RV16k/qIxW/wWc+mLzV3ARyKUaMUTBy9tOLMzFhtNSKYeTAanQ3a5MudJKf/8arIFnA2L27SNjarQKmFg0w/jA==} '@swc/core-darwin-arm64@1.6.3': resolution: {integrity: sha512-3r7cJf1BcE30iyF1rnOSKrEzIR+cqnyYSZvivrm62TZdXVsIjfXe1xulsKGxZgNeLY5erIu7ukvMvBvPhnQvqA==} @@ -1613,14 +1660,8 @@ packages: '@swc/counter@0.1.3': resolution: {integrity: sha512-e2BR4lsJkkRlKZ/qCHPw9ZaSxc0MVUd7gtbtaB7aMvHeJVYe8sOB8DBZkP2DtISHGSku9sCK6T6cnY0CtXrOCQ==} - '@swc/types@0.1.8': - resolution: {integrity: sha512-RNFA3+7OJFNYY78x0FYwi1Ow+iF1eF5WvmfY1nXPOEH4R2p/D4Cr1vzje7dNAI2aLFqpv8Wyz4oKSWqIZArpQA==} - - '@tenderly/hardhat-tenderly@2.3.0': - resolution: {integrity: sha512-Q21HeQofncnrH33Ys4Xd2HRgxl+4E/HgUqUIu6l734Cpw07KMwlsTicEML0nlVPgLDmtNrJv4cnFn4SypwioaA==} - peerDependencies: - ethers: ^6.8.1 - hardhat: ^2.22.6 + '@swc/types@0.1.17': + resolution: {integrity: sha512-V5gRru+aD8YVyCOMAjMpWR1Ui577DD5KSJsHP8RAxopAH22jFz6GZd/qxqjO6MJHQhcsjvjOFXyDhyLQUnMveQ==} '@trivago/prettier-plugin-sort-imports@3.4.0': resolution: {integrity: sha512-485Iailw8X5f7KetzRka20RF1kPBEINR5LJMNwlBZWY1gRAlVnv5dZzyNPnLxSP0Qcia8HETa9Cdd8LlX9o+pg==} @@ -1660,8 +1701,8 @@ packages: '@types/bn.js@5.1.3': resolution: {integrity: sha512-wT1B4iIO82ecXkdN6waCK8Ou7E71WU+mP1osDA5Q8c6Ur+ozU2vIKUIhSpUr6uE5L2YHocKS1Z2jG2fBC1YVeg==} - '@types/chai-as-promised@7.1.7': - resolution: {integrity: sha512-APucaP5rlmTRYKtRA6FE5QPP87x76ejw5t5guRJ4y5OgMnwtsvigw7HHhKZlx2MGXLeZd6R/GNZR/IqDHcbtQw==} + '@types/chai-as-promised@7.1.8': + resolution: {integrity: sha512-ThlRVIJhr69FLlh6IctTXFkmhtP3NpMZ2QGq69StYLyKZFp/HOp1VdKZj7RvfNWYYcJ1xlbLGLLWj1UvP5u/Gw==} '@types/chai@4.3.11': resolution: {integrity: sha512-qQR1dr2rGIHYlJulmr8Ioq3De0Le9E4MJ5AiaeAETJJpndT1uUNHsGFK3L/UIu+rbkQSdj8J/w2bCsBZc/Y5fQ==} @@ -1675,6 +1716,9 @@ packages: '@types/estree@1.0.5': resolution: {integrity: sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw==} + '@types/estree@1.0.6': + resolution: {integrity: sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw==} + '@types/form-data@0.0.33': resolution: {integrity: sha512-8BSvG1kGm83cyJITQMZSulnl6QV8jqAGreJsc5tPu1Jq0vTSOiY/k24Wx82JRpWwZSqrala6sd5rWi6aNXvqcw==} @@ -1696,15 +1740,15 @@ packages: '@types/node@10.17.60': resolution: {integrity: sha512-F0KIgDJfy2nA3zMLmWGKxcH2ZVEtCZXHHdOQs2gSaQ27+lNeEfGxzkIw90aXswATX7AZ33tahPbzy6KAfUreVw==} - '@types/node@18.15.13': - resolution: {integrity: sha512-N+0kuo9KgrUQ1Sn/ifDXsvg0TTleP7rIy4zOBGECxAljqvqfqpTfzx0Q1NUedOixRMBfe2Whhb056a42cWs26Q==} - - '@types/node@18.18.7': - resolution: {integrity: sha512-bw+lEsxis6eqJYW8Ql6+yTqkE6RuFtsQPSe5JxXbqYRFQEER5aJA9a5UH9igqDWm3X4iLHIKOHlnAXLM4mi7uQ==} + '@types/node@18.19.71': + resolution: {integrity: sha512-evXpcgtZm8FY4jqBSN8+DmOTcVkkvTmAayeo4Wf3m1xAruyVGzGuDh/Fb/WWX2yLItUiho42ozyJjB0dw//Tkw==} '@types/node@20.5.1': resolution: {integrity: sha512-4tT2UrL5LBqDwoed9wZ6N3umC4Yhz3W3FloMmiiG4JwmUJWpie0c7lcnUNd4gtMKuDEO4wRVS8B6Xa0uMRsMKg==} + '@types/node@22.7.5': + resolution: {integrity: sha512-jML7s2NAzMWc//QSJ1a3prpk78cOPchGvXJsC3C6R6PSMoooztvRVQEz89gmBTBY1SPMaqo5teB4uNHPdetShQ==} + '@types/node@8.10.66': resolution: {integrity: sha512-tktOkFUA4kXx2hhhrB8bIFb5TbwzS4uOhKEmwiD+NoiL0qtP2OQ9mFldbgD4dV1djrlBYP6eBuQZiWjuHUpqFw==} @@ -1717,8 +1761,8 @@ packages: '@types/prettier@2.7.3': resolution: {integrity: sha512-+68kP9yzs4LMp7VNh8gdzMSPZFL44MLGqiHWvttYJe+6qnuVr4Ek9wSBQoveqY/r+LwjCcU29kNVkidwim+kYA==} - '@types/qs@6.9.9': - resolution: {integrity: sha512-wYLxw35euwqGvTDx6zfY1vokBFnsK0HNrzc6xNHchxfO2hpuRg74GbkEW7e3sSmPvj0TjCDT1VCa6OtHXnubsg==} + '@types/qs@6.9.18': + resolution: {integrity: sha512-kK7dgTYDyGqS+e2Q4aK9X3D7q234CIZ1Bv0q/7Z5IwRDoADNU81xXJK/YVyLbLTZCoIwUoDoffFeF+p/eIklAA==} '@types/resolve@1.20.2': resolution: {integrity: sha512-60BCwRFOZCQhDncwQdxxeOEEkbc5dIMccYLwbxsS4TUNeVECQ/pBJ0j09mrHOl/JJvpRPGwO9SvE4nR2Nb/a4Q==} @@ -1726,8 +1770,8 @@ packages: '@types/secp256k1@4.0.5': resolution: {integrity: sha512-aIonTBMErtE3T9MxDvTZRzcrT/mCqpEZBw3CCY/i+oG9n57N/+7obBkhFgavUAIrX21bU0LHg1XRgtaLdelBhA==} - '@typescript-eslint/eslint-plugin@7.12.0': - resolution: {integrity: sha512-7F91fcbuDf/d3S8o21+r3ZncGIke/+eWk0EpO21LXhDfLahriZF9CGj4fbAetEjlaBdjdSm9a6VeXbpbT6Z40Q==} + '@typescript-eslint/eslint-plugin@7.18.0': + resolution: {integrity: sha512-94EQTWZ40mzBc42ATNIBimBEDltSJ9RQHCC8vc/PDbxi4k8dVwUAv4o98dk50M1zB+JGFxp43FP7f8+FP8R6Sw==} engines: {node: ^18.18.0 || >=20.0.0} peerDependencies: '@typescript-eslint/parser': ^7.0.0 @@ -1737,8 +1781,8 @@ packages: typescript: optional: true - '@typescript-eslint/parser@7.12.0': - resolution: {integrity: sha512-dm/J2UDY3oV3TKius2OUZIFHsomQmpHtsV0FTh1WO8EKgHLQ1QCADUqscPgTpU+ih1e21FQSRjXckHn3txn6kQ==} + '@typescript-eslint/parser@7.18.0': + resolution: {integrity: sha512-4Z+L8I2OqhZV8qA132M4wNL30ypZGYOQVBfMgxDH/K5UX0PNqTu1c6za9ST5r9+tavvHiTWmBnKzpCJ/GlVFtg==} engines: {node: ^18.18.0 || >=20.0.0} peerDependencies: eslint: ^8.56.0 @@ -1747,12 +1791,12 @@ packages: typescript: optional: true - '@typescript-eslint/scope-manager@7.12.0': - resolution: {integrity: sha512-itF1pTnN6F3unPak+kutH9raIkL3lhH1YRPGgt7QQOh43DQKVJXmWkpb+vpc/TiDHs6RSd9CTbDsc/Y+Ygq7kg==} + '@typescript-eslint/scope-manager@7.18.0': + resolution: {integrity: sha512-jjhdIE/FPF2B7Z1uzc6i3oWKbGcHb87Qw7AWj6jmEqNOfDFbJWtjt/XfwCpvNkpGWlcJaog5vTR+VV8+w9JflA==} engines: {node: ^18.18.0 || >=20.0.0} - '@typescript-eslint/type-utils@7.12.0': - resolution: {integrity: sha512-lib96tyRtMhLxwauDWUp/uW3FMhLA6D0rJ8T7HmH7x23Gk1Gwwu8UZ94NMXBvOELn6flSPiBrCKlehkiXyaqwA==} + '@typescript-eslint/type-utils@7.18.0': + resolution: {integrity: sha512-XL0FJXuCLaDuX2sYqZUUSOJ2sG5/i1AAze+axqmLnSkNEVMVYLF+cbwlB2w8D1tinFuSikHmFta+P+HOofrLeA==} engines: {node: ^18.18.0 || >=20.0.0} peerDependencies: eslint: ^8.56.0 @@ -1761,12 +1805,12 @@ packages: typescript: optional: true - '@typescript-eslint/types@7.12.0': - resolution: {integrity: sha512-o+0Te6eWp2ppKY3mLCU+YA9pVJxhUJE15FV7kxuD9jgwIAa+w/ycGJBMrYDTpVGUM/tgpa9SeMOugSabWFq7bg==} + '@typescript-eslint/types@7.18.0': + resolution: {integrity: sha512-iZqi+Ds1y4EDYUtlOOC+aUmxnE9xS/yCigkjA7XpTKV6nCBd3Hp/PRGGmdwnfkV2ThMyYldP1wRpm/id99spTQ==} engines: {node: ^18.18.0 || >=20.0.0} - '@typescript-eslint/typescript-estree@7.12.0': - resolution: {integrity: sha512-5bwqLsWBULv1h6pn7cMW5dXX/Y2amRqLaKqsASVwbBHMZSnHqE/HN4vT4fE0aFsiwxYvr98kqOWh1a8ZKXalCQ==} + '@typescript-eslint/typescript-estree@7.18.0': + resolution: {integrity: sha512-aP1v/BSPnnyhMHts8cf1qQ6Q1IFwwRvAQGRvBFkWlo3/lH29OXA3Pts+c10nxRxIBrDnoMqzhgdwVe5f2D6OzA==} engines: {node: ^18.18.0 || >=20.0.0} peerDependencies: typescript: '*' @@ -1774,14 +1818,14 @@ packages: typescript: optional: true - '@typescript-eslint/utils@7.12.0': - resolution: {integrity: sha512-Y6hhwxwDx41HNpjuYswYp6gDbkiZ8Hin9Bf5aJQn1bpTs3afYY4GX+MPYxma8jtoIV2GRwTM/UJm/2uGCVv+DQ==} + '@typescript-eslint/utils@7.18.0': + resolution: {integrity: sha512-kK0/rNa2j74XuHVcoCZxdFBMF+aq/vH83CXAOHieC+2Gis4mF8jJXT5eAfyD3K0sAxtPuwxaIOIOvhwzVDt/kw==} engines: {node: ^18.18.0 || >=20.0.0} peerDependencies: eslint: ^8.56.0 - '@typescript-eslint/visitor-keys@7.12.0': - resolution: {integrity: sha512-uZk7DevrQLL3vSnfFl5bj4sL75qC9D6EdjemIdbtkuUmIheWpuiiylSY01JxJE7+zGrOWDZrp1WxOuDntvKrHQ==} + '@typescript-eslint/visitor-keys@7.18.0': + resolution: {integrity: sha512-cDF0/Gf81QpY3xYyJKDV14Zwdmid5+uuENhjH2EqFaF0ni+yAyq/LzMaIJdhNJXZI7uLzwIlA+V7oWoyn6Curg==} engines: {node: ^18.18.0 || >=20.0.0} '@ungap/structured-clone@1.2.0': @@ -1823,8 +1867,8 @@ packages: zod: optional: true - abitype@1.0.5: - resolution: {integrity: sha512-YzDhti7cjlfaBhHutMaboYB21Ha3rXR9QTkNJFzYC4kC8YclaiwPBBBJY8ejFdu2wnJeZCVZSMlQJ7fi8S6hsw==} + abitype@1.0.7: + resolution: {integrity: sha512-ZfYYSktDQUwc2eduYu8C4wOs+RDPmnRYMh7zNfzeMtGGgb0U+6tLGjixUic6mXf5xKKCcgT5Qp6cv39tOARVFw==} peerDependencies: typescript: '>=5.0.4' zod: ^3 >=3.22.0 @@ -1876,6 +1920,9 @@ packages: ajv@8.12.0: resolution: {integrity: sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==} + ajv@8.17.1: + resolution: {integrity: sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==} + amazon-cognito-identity-js@6.3.6: resolution: {integrity: sha512-kBq+GE6OkLrxtFj3ZduIOlKBFYeOqZK3EhxbDBkv476UTvy+uwfR0tlriTq2QzNdnvlQAjBIXnXuOM7DwR1UEQ==} @@ -2011,15 +2058,6 @@ packages: resolution: {integrity: sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==} engines: {node: '>= 0.4'} - axios@0.21.4: - resolution: {integrity: sha512-ut5vewkiu8jjGBdqpM44XxjuCjq9LAKeHVmoVfHVzy8eHgxxq8SbAVQNovDA8mVi05kP0Ea/n/UzcSHcTJQfNg==} - - axios@0.27.2: - resolution: {integrity: sha512-t+yRIyySRTp/wua5xEr+z1q60QmLq8ABsS5O9Me1AsE5dfKqgnCFzwiCZZ/cGNd1lq4/7akDWMxdhVlucjmnOQ==} - - axios@1.7.2: - resolution: {integrity: sha512-2A8QhOMrbomlDuiLeK9XibIBzuHeRcqqNOHp0Cyp5EoJ1IFDh+XZH3A6BkXtv0K4gFGCI0Y4BM7B1wOEi0Rmgw==} - axios@1.7.9: resolution: {integrity: sha512-LhLcE7Hbiryz8oMDdDptSrWowmB4Bl6RCt6sIJKpRB4XtVf0iEgewX3au/pJqm+Py1kCASkb/FFKjxQaLtxJvw==} @@ -2071,6 +2109,10 @@ packages: resolution: {integrity: sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==} engines: {node: '>=8'} + braces@3.0.3: + resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==} + engines: {node: '>=8'} + brorand@1.1.0: resolution: {integrity: sha512-cKV8tMCEpQs4hK/ik71d6LrPOnpkpGBR0wzxqr68g2m/LB2GxVYQroAjMJZRVM1Y4BCjCKc3vAamxSzOY2RP+w==} @@ -2111,10 +2153,6 @@ packages: resolution: {integrity: sha512-9oR3zNdupcg/Ge2sSHQF3GX+kmvL/fTPvD0nd5AGLq8SjUYnTz+SlFjK/GXidndbZtIj+pVKXiWeR9w6e9wKCA==} engines: {node: '>=14.0.0'} - builtin-modules@3.3.0: - resolution: {integrity: sha512-zhaCDicdLuWN5UbN5IMnFqNMhNfo919sH85y2/ea+5Yg9TsTkeZxpL+JLbp6cgYFS4sRLp3YV4S6yDuqVWHYOw==} - engines: {node: '>=6'} - builtins@2.0.1: resolution: {integrity: sha512-XkkVe5QAb6guWPXTzpSrYpSlN3nqEmrrE2TkAr/tp7idSF6+MONh9WvKrAuR3HiKLvoSgmbs8l1U9IPmMrIoLw==} @@ -2126,10 +2164,18 @@ packages: resolution: {integrity: sha512-A+Fezp4zxnit6FanDmv9EqXNAi3vt9DWp51/71UEhXukb7QUuvtv9344h91dyAxuTLoSYJFU299qzR3tzwPAhw==} engines: {node: '>=6'} + call-bind-apply-helpers@1.0.1: + resolution: {integrity: sha512-BhYE+WDaywFg2TBWYNXAE+8B1ATnThNBqXHP5nQu0jWJdVvY2hvkpyB3qOmtmDePiS5/BDQ8wASEWGMWRG148g==} + engines: {node: '>= 0.4'} + call-bind@1.0.7: resolution: {integrity: sha512-GHTSNSYICQ7scH7sZ+M2rFopRoLh8t2bLSW6BbgrtLsahOIB5iyAVJf9GjWK3cYTDaMj4XdBpM1cA6pIS0Kv2w==} engines: {node: '>= 0.4'} + call-bound@1.0.3: + resolution: {integrity: sha512-YTd+6wGlNlPxSuri7Y6X8tY2dmm12UMH66RpKMhiX6rsk5wXXnYgbUcOt8kiS31/AjfoTOvCsE+w8nZQLQnzHA==} + engines: {node: '>= 0.4'} + callsites@3.1.0: resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==} engines: {node: '>=6'} @@ -2160,10 +2206,14 @@ packages: resolution: {integrity: sha512-/TQOWyamDxvVIv+DY9cOLNuABkoyz8K/F3QE56539pGVYohx0+MEA1f4lChFTX79dBTBS7R1PF6ovH7G+VtBfQ==} engines: {node: '>=16'} - chai-as-promised@7.1.1: - resolution: {integrity: sha512-azL6xMoi+uxu6z4rhWQ1jbdUhOMhis2PvscD/xjLqNMkv3BPPp2JyyuTHOrf9BOosGpNQ11v6BKv/g57RXbiaA==} + cbor@9.0.2: + resolution: {integrity: sha512-JPypkxsB10s9QOWwa6zwPzqE1Md3vqpPc+cai4sAecuCsRyAtAl/pMyhPlMbT/xtPnm2dznJZYRLui57qiRhaQ==} + engines: {node: '>=16'} + + chai-as-promised@7.1.2: + resolution: {integrity: sha512-aBDHZxRzYnUYuIAIPBH2s511DjlKPzXNlXSGFC8CwmroWQLfrW0LtE1nK3MAwwNhJPa9raEjNCmRoFpG0Hurdw==} peerDependencies: - chai: '>= 2.1.2 < 5' + chai: '>= 2.1.2 < 6' chai@4.5.0: resolution: {integrity: sha512-RITGBfijLkBddZvnn8jdqoTypxvqbOLYQkGGxXzeFjVHvudaPw0HNFD9x928/eUwYWd2dPCugVqspGALTZZQKw==} @@ -2232,10 +2282,6 @@ packages: resolution: {integrity: sha512-7Qg2Jrep1S/+Q3EceiZtQcDPWxhAvBw+ERf1162v4sikJrvojMHFqXt8QIVha8UlH9rgU0BeWPytZ9/TzYqlUw==} engines: {node: '>=6'} - cli-table3@0.6.3: - resolution: {integrity: sha512-w5Jac5SykAeZJKntOxJCrm63Eg5/4dhMWIcuTbo9rpE+brgaSZo0RuNJZeOyMgsUdhDeojvgyQLmjI+K50ZGyg==} - engines: {node: 10.* || >= 12.*} - cli-truncate@3.1.0: resolution: {integrity: sha512-wfOBkjXteqSnI59oPcJkcPl/ZmwvMMOj340qUIY1SKZCv0B9Cf4D4fAucRkIKQmsIuYK3x1rrgU7MeGRruiuiA==} engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} @@ -2302,12 +2348,8 @@ packages: resolution: {integrity: sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==} engines: {node: '>= 12'} - commander@9.5.0: - resolution: {integrity: sha512-KRs7WVDKg86PWiuAqhDrAQnTXZKraVcCc6vFdL14qrZ/DcWwuRo7VoiYXalXO7S5GKpqYiVEwCbgFDfxNHKJBQ==} - engines: {node: ^12.20.0 || >=14} - - commitizen@4.3.0: - resolution: {integrity: sha512-H0iNtClNEhT0fotHvGV3E9tDejDeS04sN1veIebsKYGMuGscFaswRoYJKmT3eW85eIJAs0F28bG2+a/9wCOfPw==} + commitizen@4.3.1: + resolution: {integrity: sha512-gwAPAVTy/j5YcOOebcCRIijn+mSjWJC+IYKivTu6aG8Ei/scoXgfsMRnuAk6b0GRste2J4NGxVdMN3ZpfNaVaw==} engines: {node: '>= 12'} hasBin: true @@ -2432,6 +2474,15 @@ packages: supports-color: optional: true + debug@4.4.0: + resolution: {integrity: sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==} + engines: {node: '>=6.0'} + peerDependencies: + supports-color: '*' + peerDependenciesMeta: + supports-color: + optional: true + decamelize-keys@1.1.1: resolution: {integrity: sha512-WiPxgEirIV0/eIOMcnFBA3/IJZAZqKnwAwWyvvdi4lsr1WCN22nhdf/3db3DoZcUjTV2SqfzIwNyp6y2xs3nmg==} engines: {node: '>=0.10.0'} @@ -2451,6 +2502,10 @@ packages: resolution: {integrity: sha512-WaEtAOpRA1MQ0eohqZjpGD8zdI0Ovsm8mmFhaDN8dvDZzyoUMcYDnf5Y6iu7HTXxf8JDS23qWa4a+hKCDyOPzw==} engines: {node: '>=6'} + deep-eql@4.1.4: + resolution: {integrity: sha512-SUwdGfqdKOwxCPeVYjwSyRpJ7Z+fhpwIAtmCUdZIWZ/YP5R9WAsyuSgpLVDi9bjWoN2LXHNss/dk3urXtdQxGg==} + engines: {node: '>=6'} + deep-extend@0.6.0: resolution: {integrity: sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==} engines: {node: '>=4.0.0'} @@ -2469,10 +2524,6 @@ packages: resolution: {integrity: sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==} engines: {node: '>= 0.4'} - define-lazy-prop@2.0.0: - resolution: {integrity: sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og==} - engines: {node: '>=8'} - define-properties@1.2.1: resolution: {integrity: sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==} engines: {node: '>= 0.4'} @@ -2498,8 +2549,9 @@ packages: resolution: {integrity: sha512-reYkTUJAZb9gUuZ2RvVCNhVHdg62RHnJ7WJl8ftMi4diZ6NWlciOzQN88pUhSELEwflJht4oQDv0F0BMlwaYtA==} engines: {node: '>=8'} - detect-port@1.5.1: - resolution: {integrity: sha512-aBzdj76lueB6uUst5iAs7+0H/oOjqI5D16XUWxlWMIMROhcM0rfsNVk93zTngq1dDNpoXRr++Sus7ETAExppAQ==} + detect-port@1.6.1: + resolution: {integrity: sha512-CmnVc+Hek2egPx1PeTFVta2W78xy2K/9Rkf6cC4T59S50tVnzKj+tnx5mmx5lwvCkujZ4uRrpRSuV+IVs3f90Q==} + engines: {node: '>= 4.0.0'} hasBin: true diff@4.0.2: @@ -2510,6 +2562,10 @@ packages: resolution: {integrity: sha512-/VTCrvm5Z0JGty/BWHljh+BAiw3IK+2j87NGMu8Nwc/f48WoDAC395uomO9ZD117ZOBaHmkX1oyLvkVM/aIT3w==} engines: {node: '>=0.3.1'} + diff@5.2.0: + resolution: {integrity: sha512-uIFDxqpRZGZ6ThOk84hEfqWoHx2devRFvpTZcTHur85vImfaxUbTW9Ryh4CpCuDnToOP1CEtXKIgytHBPVff5A==} + engines: {node: '>=0.3.1'} + difflib@0.2.4: resolution: {integrity: sha512-9YVwmMb0wQHQNr5J9m6BSj6fk4pfGITGQOOs+D9Fl+INODWFOfvhIU1hNv6GgR1RBoC/9NJcwu77zShxV0kT7w==} @@ -2525,10 +2581,14 @@ packages: resolution: {integrity: sha512-QM8q3zDe58hqUqjraQOmzZ1LIH9SWQJTlEKCH4kJ2oQvLZk7RbQXvtDM2XEq3fwkV9CCvvH4LA0AV+ogFsBM2Q==} engines: {node: '>=8'} - dotenv@16.3.1: - resolution: {integrity: sha512-IPzF4w4/Rd94bA9imS68tZBaYyBWSCE47V1RGuMrB94iyTOIEwRmVL2x/4An+6mETpLrKJ5hQkB8W4kFAadeIQ==} + dotenv@16.4.7: + resolution: {integrity: sha512-47qPchRCykZC03FhkYAhrvwU4xDBFIj1QPqaarj6mdM/hgUzfPHcpkHJOn3mJAufFeeAxAzeGsr5X0M4k6fLZQ==} engines: {node: '>=12'} + dunder-proto@1.0.1: + resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==} + engines: {node: '>= 0.4'} + eastasianwidth@0.2.0: resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==} @@ -2569,6 +2629,10 @@ packages: resolution: {integrity: sha512-jxayLKShrEqqzJ0eumQbVhTYQM27CfT1T35+gCgDFoL82JLsXqTJ76zv6A0YLOgEnLUMvLzsDsGIrl8NFpT2gQ==} engines: {node: '>= 0.4'} + es-define-property@1.0.1: + resolution: {integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==} + engines: {node: '>= 0.4'} + es-errors@1.3.0: resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==} engines: {node: '>= 0.4'} @@ -2580,6 +2644,10 @@ packages: resolution: {integrity: sha512-MZ4iQ6JwHOBQjahnjwaC1ZtIBH+2ohjamzAO3oaHcXYup7qxjF2fixyH+Q71voWHeOkI2q/TnJao/KfXYIZWbw==} engines: {node: '>= 0.4'} + es-object-atoms@1.1.1: + resolution: {integrity: sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==} + engines: {node: '>= 0.4'} + es-set-tostringtag@2.0.3: resolution: {integrity: sha512-3T8uNMC3OQTHkFUsFq8r/BwAXLHvU/9O9mE0fBc/MY5iq/8H7ncvO947LmYA6ldWw9Uh8Yhf25zu6n7nML5QWQ==} engines: {node: '>= 0.4'} @@ -2627,9 +2695,10 @@ packages: resolution: {integrity: sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - eslint@8.52.0: - resolution: {integrity: sha512-zh/JHnaixqHZsolRB/w9/02akBk9EPrOs9JwcTP2ek7yL5bVvXuRariiaAjjoJ5DvuwQ1WAE/HsMz+w17YgBCg==} + eslint@8.57.1: + resolution: {integrity: sha512-ypowyDxpVSYpkXr9WPv2PAZCtNip1Mv5KTW0SCurXv/9iOpcrH9PaqUElksqEB6pChqHGDRCFTyrZlGhnLNGiA==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + deprecated: This version is no longer supported. Please see https://eslint.org/version-support for other options. hasBin: true espree@9.6.1: @@ -2680,8 +2749,8 @@ packages: '@codechecks/client': optional: true - ethereum-bloom-filters@1.0.10: - resolution: {integrity: sha512-rxJ5OFN3RwjQxDcFP2Z5+Q9ho4eIdEmSc2ht0fCu8Se9nbXjZ7/031uXoUYJ87KHCOdVeiUuwSnoS7hmYAGVHA==} + ethereum-bloom-filters@1.2.0: + resolution: {integrity: sha512-28hyiE7HVsWubqhpVLVmZXFd4ITeHi+BUu05o9isf0GUpMtzBUi+8/gFrGaGYzvGAJQmJ3JKj77Mk9G98T84rA==} ethereum-cryptography@0.1.3: resolution: {integrity: sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==} @@ -2689,8 +2758,8 @@ packages: ethereum-cryptography@1.2.0: resolution: {integrity: sha512-6yFQC9b5ug6/17CQpCyE3k9eKBMdhyVjzUy1WkiuY/E4vj/SXDBbCw8QEIaXqf0Mf2SnY6RmpDcwlUmBSS0EJw==} - ethereum-cryptography@2.1.2: - resolution: {integrity: sha512-Z5Ba0T0ImZ8fqXrJbpHcbpAvIswRte2wGNR/KePnu8GbbvgJ47lMxT/ZZPG6i9Jaht4azPDop4HaM00J0J59ug==} + ethereum-cryptography@2.2.1: + resolution: {integrity: sha512-r/W8lkHSiTLxUxW8Rf3u4HGB0xQweG2RyETjywylKZSzLWoWAijRz8WCuOtJ6wah+avllXBqZuk29HCCvhEIRg==} ethereumjs-abi@0.6.8: resolution: {integrity: sha512-Tx0r/iXI6r+lRsdvkFDlut0N08jWMnKRZ6Gkq+Nmw75lZe4e6o3EkSnkaBP5NF6+m5PTGAr9JP43N3LyeoglsA==} @@ -2705,12 +2774,8 @@ packages: ethers@5.7.2: resolution: {integrity: sha512-wswUsmWo1aOK8rR7DIKiWSw9DbLWe6x98Jrn8wcTflTVvaXhAMaB5zGAXy0GYQEQp9iO1iSHWVyARQm11zUtyg==} - ethers@6.13.1: - resolution: {integrity: sha512-hdJ2HOxg/xx97Lm9HdCWk949BfYqYWpyw4//78SiwOLgASyfrNszfMUNB2joKjvGUdwhHfaiMMFFwacVVoLR9A==} - engines: {node: '>=14.0.0'} - - ethers@6.9.0: - resolution: {integrity: sha512-pmfNyQzc2mseLe91FnT2vmNaTt8dDzhxZ/xItAV7uGsF4dI4ek2ufMu3rAkgQETL/TIs0GS5A+U05g9QyWnv3Q==} + ethers@6.13.5: + resolution: {integrity: sha512-+knKNieu5EKRThQJWwqaJ10a6HE9sSehGeqWN65//wE7j47ZpFhKAnHB/JJFibwwg61I/koxaPsXbXpD/skNOQ==} engines: {node: '>=14.0.0'} ethjs-unit@0.1.6: @@ -2752,8 +2817,8 @@ packages: fast-diff@1.3.0: resolution: {integrity: sha512-VxPP4NqbUjj6MaAOafWeUn2cXWLcCtljklUtZf0Ind4XQ+QPtmA0b18zZy0jIQx+ExRVCR/ZQpBmik5lXshNsw==} - fast-glob@3.3.2: - resolution: {integrity: sha512-oX2ruAFQwf/Orj8m737Y5adxDQO0LAB7/S5MnxCdTNDd4p6BsyIVsv9JQsATbTSq8KHRpLwIHbVlUNatxd+1Ow==} + fast-glob@3.3.3: + resolution: {integrity: sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==} engines: {node: '>=8.6.0'} fast-json-stable-stringify@2.1.0: @@ -2762,6 +2827,9 @@ packages: fast-levenshtein@2.0.6: resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==} + fast-uri@3.0.5: + resolution: {integrity: sha512-5JnBCWpFlMo0a3ciDy/JckMzzv1U9coZrIhedq+HXxxUfDTAiS0LA8OKVao4G9BxmCVck/jtA5r3KAtRWEyD8Q==} + fast-xml-parser@4.4.1: resolution: {integrity: sha512-xkjOecfnKGkSsOwtZ5Pz7Us/T6mrbPQrq0nh+aCO5V9nk5NLWmasAHumTKjiPJPWANe+kAZ84Jc8ooJkzZ88Sw==} hasBin: true @@ -2789,6 +2857,10 @@ packages: resolution: {integrity: sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==} engines: {node: '>=8'} + fill-range@7.1.1: + resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==} + engines: {node: '>=8'} + find-node-modules@2.1.3: resolution: {integrity: sha512-UC2I2+nx1ZuOBclWVNdcnbDR5dlrOdVb7xNjmT/lHE+LsgztWks3dG7boJ37yTS/venXw84B/mAW9uHVoC5QRg==} @@ -2841,8 +2913,8 @@ packages: resolution: {integrity: sha512-TMKDUnIte6bfb5nWv7V/caI169OHgvwjb7V4WkeUvbQQdjr5rWKqHFiKWb/fcOwB+CzBT+qbWjvj+DVwRskpIg==} engines: {node: '>=14'} - form-data@2.5.1: - resolution: {integrity: sha512-m21N3WOmEEURgk6B9GLOE4RuWOFf28Lhh9qGYeNlGq4VDXUlJy2th2slBNU8Gp8EzloYZOibZJ7t5ecIrFSjVA==} + form-data@2.5.2: + resolution: {integrity: sha512-GgwY0PS7DbXqajuGf4OYlsrIu3zgxD6Vvql43IBhm6MahqA5SK/7mwhtNj2AdH2z35YR34ujJ7BN+3fFC3jP5Q==} engines: {node: '>= 0.12'} form-data@4.0.0: @@ -2908,10 +2980,18 @@ packages: resolution: {integrity: sha512-5uYhsJH8VJBTv7oslg4BznJYhDoRI6waYCxMmCdnTrcCrHA/fCFKoTFz2JKKE0HdDFUF7/oQuhzumXJK7paBRQ==} engines: {node: '>= 0.4'} + get-intrinsic@1.2.7: + resolution: {integrity: sha512-VW6Pxhsrk0KAOqs3WEd0klDiF/+V7gQOpAvY1jVU/LHmaD/kQO4523aiJuikX/QAKYiW6x8Jh+RJej1almdtCA==} + engines: {node: '>= 0.4'} + get-port@3.2.0: resolution: {integrity: sha512-x5UJKlgeUiNT8nyo/AcnwLnZuZNcSjSw0kogRB+Whd1fjjFq4B1hySFxSFWWSn4mIBzg3sRNUDFYc4g5gjPoLg==} engines: {node: '>=4'} + get-proto@1.0.1: + resolution: {integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==} + engines: {node: '>= 0.4'} + get-stream@6.0.1: resolution: {integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==} engines: {node: '>=10'} @@ -3008,6 +3088,10 @@ packages: gopd@1.0.1: resolution: {integrity: sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==} + gopd@1.2.0: + resolution: {integrity: sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==} + engines: {node: '>= 0.4'} + graceful-fs@4.2.11: resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==} @@ -3029,9 +3113,6 @@ packages: peerDependencies: hardhat: ^2.0.0 - hardhat-deploy@0.11.45: - resolution: {integrity: sha512-aC8UNaq3JcORnEUIwV945iJuvBwi65tjHVDU3v6mOcqik7WAzHVCJ7cwmkkipsHrWysrB5YvGF1q9S1vIph83w==} - hardhat-gas-reporter@1.0.9: resolution: {integrity: sha512-INN26G3EW43adGKBNzYWOlI3+rlLnasXTwW79YNnUhXPDa+yHESgt639dJEs37gCjhkbNKcRRJnomXEuMFBXJg==} peerDependencies: @@ -3080,6 +3161,10 @@ packages: resolution: {integrity: sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==} engines: {node: '>= 0.4'} + has-symbols@1.1.0: + resolution: {integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==} + engines: {node: '>= 0.4'} + has-tostringtag@1.0.2: resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==} engines: {node: '>= 0.4'} @@ -3159,6 +3244,10 @@ packages: resolution: {integrity: sha512-5Fytz/IraMjqpwfd34ke28PTVMjZjJG2MPn5t7OE4eUCUNf8BAa7b5WUS9/Qvr6mwOQS7Mk6vdsMno5he+T8Xw==} engines: {node: '>= 4'} + ignore@5.3.2: + resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==} + engines: {node: '>= 4'} + immer@10.0.2: resolution: {integrity: sha512-Rx3CqeqQ19sxUtYV9CU911Vhy8/721wRFnJv3REVGWUmoAcIwzifTsdmJte/MV+0/XpM35LZdQMBGkRIoLPwQA==} @@ -3223,10 +3312,6 @@ packages: resolution: {integrity: sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==} engines: {node: '>= 0.4'} - is-builtin-module@3.2.1: - resolution: {integrity: sha512-BSLE3HnV2syZ0FK0iMA/yUGplUeMmNz4AW5fnTunbCIqZi4vG3WjJT9FHMy5D69xmAYBHXQhJdALdpwVxV501A==} - engines: {node: '>=6'} - is-callable@1.2.7: resolution: {integrity: sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==} engines: {node: '>= 0.4'} @@ -3242,11 +3327,6 @@ packages: resolution: {integrity: sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==} engines: {node: '>= 0.4'} - is-docker@2.2.1: - resolution: {integrity: sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==} - engines: {node: '>=8'} - hasBin: true - is-extglob@2.1.1: resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==} engines: {node: '>=0.10.0'} @@ -3355,10 +3435,6 @@ packages: resolution: {integrity: sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==} engines: {node: '>=0.10.0'} - is-wsl@2.2.0: - resolution: {integrity: sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==} - engines: {node: '>=8'} - isarray@1.0.0: resolution: {integrity: sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==} @@ -3371,8 +3447,8 @@ packages: isomorphic-unfetch@3.1.0: resolution: {integrity: sha512-geDJjpoZ8N0kWexiwkX8F9NkTsXhetLPVbZFQ+JTW239QNOwvB0gniuR1Wc6f0AMTn7/mFGyXvHTifrCp/GH8Q==} - isows@1.0.4: - resolution: {integrity: sha512-hEzjY+x9u9hPmBom9IIAqdJCwNLax+xrPb51vEPpERoFlIxgmZcHzsT5jKG06nvInKOBGvReAVz80Umed5CczQ==} + isows@1.0.6: + resolution: {integrity: sha512-lPHCayd40oW98/I0uvgaHKWCSvkzY27LjWLbtzOm64yQ+G3Q5npjjbdppU65iZXkK1Zt+kH9pfegli0AYfwYYw==} peerDependencies: ws: '*' @@ -3449,8 +3525,8 @@ packages: resolution: {integrity: sha512-POQXvpdL69+CluYsillJ7SUhKvytYjW9vG/GKpnf+xP8UWgYEM/RaMzHHofbALDiKbbP1W8UEYmgGl39WkPZsg==} engines: {'0': node >= 0.2.0} - jsonschema@1.4.1: - resolution: {integrity: sha512-S6cATIPVv1z0IlxdN+zUk5EPjkGCdnhN4wVSBlvoUO1tOLJootbo9CquNJmbIh4yikWHiUedhRYrNPn1arpEmQ==} + jsonschema@1.5.0: + resolution: {integrity: sha512-K+A9hhqbn0f3pJX17Q/7H6yQfD/5OXgdrR5UE12gMXCiN9D5Xq2o5mddV2QEcX/bjla99ASsAAQUyMCCRWAEhw==} keccak@3.0.4: resolution: {integrity: sha512-3vKuW0jV8J3XNTzvfyicFR5qvxrSAGl7KIhvgOu5cmWwM7tZRj3fMbj/pfIf4be7aznbc+prBWGjywox/g2Y6Q==} @@ -3613,8 +3689,9 @@ packages: markdown-table@1.1.3: resolution: {integrity: sha512-1RUZVgQlpJSPWYbFSpmudq5nHY1doEIv89gBtF0s4gW1GF2XorxcA/70M5vq7rLv0a6mhOUccRsqkwhwLCIQ2Q==} - match-all@1.2.6: - resolution: {integrity: sha512-0EESkXiTkWzrQQntBu2uzKvLu6vVkUGz40nGPbSZuegcfE5UuSzNjLaIu76zJWuaT/2I3Z/8M06OlUOZLGwLlQ==} + math-intrinsics@1.1.0: + resolution: {integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==} + engines: {node: '>= 0.4'} md5.js@1.3.5: resolution: {integrity: sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==} @@ -3644,6 +3721,10 @@ packages: resolution: {integrity: sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==} engines: {node: '>=8.6'} + micromatch@4.0.8: + resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==} + engines: {node: '>=8.6'} + mime-db@1.52.0: resolution: {integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==} engines: {node: '>= 0.6'} @@ -3720,6 +3801,11 @@ packages: engines: {node: '>= 14.0.0'} hasBin: true + mocha@10.8.2: + resolution: {integrity: sha512-VZlYo/WE8t1tstuRmqgeyBgCbJc/lEdopaa+axcKzTBJ+UIdlAB9XnmvTCAH4pwR4ElNInaedhEBmZD8iCSVEg==} + engines: {node: '>= 14.0.0'} + hasBin: true + ms@2.1.2: resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==} @@ -3759,10 +3845,6 @@ packages: node-emoji@1.11.0: resolution: {integrity: sha512-wo2DpQkQp7Sjm2A0cq+sN7EHKO6Sl0ctXeBdFZrL9T9+UywORbufTcTZxom8YqpLQt/FqNMUkOpkZrJVYSKD3A==} - node-fetch@2.0.0: - resolution: {integrity: sha512-bici2HCWFnAghTYMcy12WPxrEwJ5qK7GQJOTwTfyEZjyL99ECWxbYQfabZ2U1zrHMKkOBE97Z9iHIuKQfCMdzQ==} - engines: {node: 4.x || >=6.0.0} - node-fetch@2.7.0: resolution: {integrity: sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==} engines: {node: 4.x || >=6.0.0} @@ -3776,6 +3858,10 @@ packages: resolution: {integrity: sha512-24vnklJmyRS8ViBNI8KbtK/r/DmXQMRiOMXTNz2nrTnAYUwjmEEbnnpB/+kt+yWRv73bPsSPRFddrcIbAxSiMQ==} hasBin: true + node-gyp-build@4.8.4: + resolution: {integrity: sha512-LA4ZjwlnUblHVgq0oBF3Jl/6h/Nvs5fzBLwdEF4nuxnFdsfajde4WfxtJr3CaiH+F6ewcIB/q4jQ4UzPyid+CQ==} + hasBin: true + node-releases@2.0.13: resolution: {integrity: sha512-uYr7J37ae/ORWdZeQ1xxMJe3NtdmqMC/JZK+geofDrkLUApKRHPd18/TxtBOJ4A0/+uUIliorNrfYV6s1b02eQ==} @@ -3817,6 +3903,10 @@ packages: object-inspect@1.13.1: resolution: {integrity: sha512-5qoj1RUiKOMsCCNLV1CBiPYE10sziTsnmNxkAI/rZhiD63CF7IqdFGC/XzjWjpSgLf0LxXX3bDFIh0E18f6UhQ==} + object-inspect@1.13.3: + resolution: {integrity: sha512-kDCGIbxkDSXE3euJZZXzc6to7fCrKHNI/hSRQnRuQ+BWjFNzZwiFF8fj/6o2t2G9/jTj8PSIYTfCLelLZEeRpA==} + engines: {node: '>= 0.4'} + object-keys@1.1.1: resolution: {integrity: sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==} engines: {node: '>= 0.4'} @@ -3839,10 +3929,6 @@ packages: resolution: {integrity: sha512-1FlR+gjXK7X+AsAHso35MnyN5KqGwJRi/31ft6x0M194ht7S+rWAvd7PHss9xSKMzE0asv1pyIHaJYq+BbacAQ==} engines: {node: '>=12'} - open@8.4.2: - resolution: {integrity: sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ==} - engines: {node: '>=12'} - optionator@0.8.3: resolution: {integrity: sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA==} engines: {node: '>= 0.8.0'} @@ -3862,6 +3948,14 @@ packages: resolution: {integrity: sha512-D2FR03Vir7FIu45XBY20mTb+/ZSWB00sjU9jdQXt83gDrI4Ztz5Fs7/yy74g2N5SVQY4xY1qDr4rNddwYRVX0g==} engines: {node: '>=0.10.0'} + ox@0.6.5: + resolution: {integrity: sha512-vmnH8KvMDwFZDbNY1mq2CBRBWIgSliZB/dFV0xKp+DfF/dJkTENt6nmA+DzHSSAgL/GO2ydjkXWvlndJgSY4KQ==} + peerDependencies: + typescript: '>=5.4.0' + peerDependenciesMeta: + typescript: + optional: true + p-limit@2.3.0: resolution: {integrity: sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==} engines: {node: '>=6'} @@ -3998,11 +4092,11 @@ packages: resolution: {integrity: sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w==} engines: {node: '>=6.0.0'} - prettier-plugin-solidity@1.1.3: - resolution: {integrity: sha512-fQ9yucPi2sBbA2U2Xjh6m4isUTJ7S7QLc/XDDsktqqxYfTwdYKJ0EnnywXHwCGAaYbQNK+HIYPL1OemxuMsgeg==} - engines: {node: '>=12'} + prettier-plugin-solidity@1.4.2: + resolution: {integrity: sha512-VVD/4XlDjSzyPWWCPW8JEleFa8JNKFYac5kNlMjVXemQyQZKfpekPMhFZSePuXB6L+RixlFvWe20iacGjFYrLw==} + engines: {node: '>=18'} peerDependencies: - prettier: '>=2.3.0 || >=3.0.0-alpha.0' + prettier: '>=2.3.0' prettier@2.8.8: resolution: {integrity: sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==} @@ -4029,8 +4123,8 @@ packages: resolution: {integrity: sha512-rRV+zQD8tVFys26lAGR9WUuS4iUAngJScM+ZRSKtvl5tKeZ2t5bvdNFdNHBW9FWR4guGHlgmsZ1G7BSm2wTbuA==} engines: {node: '>=6'} - qs@6.11.2: - resolution: {integrity: sha512-tDNIz22aBzCDxLtVH++VnTfzxlfeK5CbqohpSqpJgj1Wg/cQbStNAz3NuqCs5vV+pjBsK4x4pN9HlVh7rcYRiA==} + qs@6.14.0: + resolution: {integrity: sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w==} engines: {node: '>=0.6'} queue-microtask@1.2.3: @@ -4168,15 +4262,16 @@ packages: rimraf@2.7.1: resolution: {integrity: sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==} + deprecated: Rimraf versions prior to v4 are no longer supported hasBin: true rimraf@3.0.2: resolution: {integrity: sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==} + deprecated: Rimraf versions prior to v4 are no longer supported hasBin: true - rimraf@5.0.5: - resolution: {integrity: sha512-CqDakW+hMe/Bz202FPEymy68P+G50RfMQK+Qo5YUqc9SPipvbGjCGKd0RSKEelbsfQuw3g5NZDSrlZZAJurH1A==} - engines: {node: '>=14'} + rimraf@5.0.10: + resolution: {integrity: sha512-l0OE8wL34P4nJH/H2ffoaniAokM2qSmrtXHmlpvYr5AVVX8msAyW0l8NVJFDxlSK4u3Uh/f41cQheDVdnYijwQ==} hasBin: true ripemd160@2.0.2: @@ -4199,8 +4294,8 @@ packages: rollup: ^3.29.4 || ^4 typescript: ^4.5 || ^5.0 - rollup-plugin-esbuild@6.1.0: - resolution: {integrity: sha512-HPpXU65V8bSpW8eSYPahtUJaJHmbxJGybuf/M8B3bz/6i11YaYHlNNJIQ38gSEV0FyohQOgVxJ2YMEEZtEmwvA==} + rollup-plugin-esbuild@6.1.1: + resolution: {integrity: sha512-CehMY9FAqJD5OUaE/Mi1r5z0kNeYxItmRO2zG4Qnv2qWKF09J2lTy5GUzjJR354ZPrLkCj4fiBN41lo8PzBUhw==} engines: {node: '>=14.18.0'} peerDependencies: esbuild: '>=0.18.0' @@ -4227,8 +4322,8 @@ packages: peerDependencies: rollup: ^2.0.0 || ^3.0.0 || ^4.0.0 - rollup@4.6.1: - resolution: {integrity: sha512-jZHaZotEHQaHLgKr8JnQiDT1rmatjgKlMekyksz+yk9jt/8z9quNjnKNRoaM0wd9DC2QKXjmWWuDYtM3jfF8pQ==} + rollup@4.31.0: + resolution: {integrity: sha512-9cCE8P4rZLx9+PjoyqHLs31V9a9Vpvfo4qNcs6JCiGWYhw2gijSetFbH6SSy1whnkgcefnUwr8sad7tgqsGvnw==} engines: {node: '>=18.0.0', npm: '>=8.0.0'} hasBin: true @@ -4291,9 +4386,17 @@ packages: engines: {node: '>=10'} hasBin: true + semver@7.6.3: + resolution: {integrity: sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==} + engines: {node: '>=10'} + hasBin: true + serialize-javascript@6.0.0: resolution: {integrity: sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==} + serialize-javascript@6.0.2: + resolution: {integrity: sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==} + set-function-length@1.2.2: resolution: {integrity: sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==} engines: {node: '>= 0.4'} @@ -4333,9 +4436,25 @@ packages: engines: {node: '>=6'} hasBin: true + side-channel-list@1.0.0: + resolution: {integrity: sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==} + engines: {node: '>= 0.4'} + + side-channel-map@1.0.1: + resolution: {integrity: sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==} + engines: {node: '>= 0.4'} + + side-channel-weakmap@1.0.2: + resolution: {integrity: sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==} + engines: {node: '>= 0.4'} + side-channel@1.0.4: resolution: {integrity: sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==} + side-channel@1.1.0: + resolution: {integrity: sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==} + engines: {node: '>= 0.4'} + signal-exit@3.0.7: resolution: {integrity: sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==} @@ -4376,17 +4495,14 @@ packages: solidity-ast@0.4.52: resolution: {integrity: sha512-iOya9BSiB9jhM8Vf40n8lGELGzwrUc57rl5BhfNtJ5cvAaMvRcNlHeAMNvqJJyjoUnczqRbHqdivEqK89du3Cw==} - solidity-comments-extractor@0.0.7: - resolution: {integrity: sha512-wciNMLg/Irp8OKGrh3S2tfvZiZ0NEyILfcRCXCD4mp7SgK/i9gzLfhY2hY7VMCQJ3kH9UB9BzNdibIVMchzyYw==} - solidity-coverage@0.8.5: resolution: {integrity: sha512-6C6N6OV2O8FQA0FWA95FdzVH+L16HU94iFgg5wAFZ29UpLFkgNI/DRR2HotG1bC0F4gAc/OMs2BJI44Q/DYlKQ==} hasBin: true peerDependencies: hardhat: ^2.11.0 - solmate@6.2.0: - resolution: {integrity: sha512-AM38ioQ2P8zRsA42zenb9or6OybRjOLXIu3lhIT8rhddUuduCt76pUEuLxOIg9GByGojGz+EbpFdCB6B+QZVVA==} + solmate@6.8.0: + resolution: {integrity: sha512-/oI8kgEvSxGG1mrFv3FmCEZd0F8Z9VzRmoYMIhzmmzt6mjtPwfdCm3oh8yOL7bMHJBSfXJuMpnMPrM0uyaKsKg==} source-map-js@1.0.2: resolution: {integrity: sha512-R0XvVJ9WusLiqTCEiGCmICCMplcCkIwwR11mOSD9CR5u+IXYdiseeEuXCVAjS54zqwkLcPNnmU4OeJ6tUrWhDw==} @@ -4554,16 +4670,9 @@ packages: resolution: {integrity: sha512-Y4X9zqrCftUhMeH2EptSSERdVKt/nEdijTOacGD/97EKjhQ/Qs8RTlEGABSJNNN8lac9kheH+af7yAkEWlgneA==} engines: {node: '>=10.0.0'} - tenderly@0.9.1: - resolution: {integrity: sha512-EGhYYbOgIC0EUebrMIwCRIL9NrGrC8q3gTY/3JNSqvQrNX4RLUgMHungTG4bkgGAwJoehC57vsAeKqR1PVIyjw==} - peerDependencies: - ts-node: '*' - typescript: '*' - peerDependenciesMeta: - ts-node: - optional: true - typescript: - optional: true + table@6.9.0: + resolution: {integrity: sha512-9kY+CygyYM6j02t5YFHbNz2FN5QmYGv9zAjVp4lCDjlCw7amdckXlEt/bjMhUIfj4ThGRE4gCUH5+yGnNuPo5A==} + engines: {node: '>=10.0.0'} text-extensions@1.9.0: resolution: {integrity: sha512-wiBrwC1EhBelW12Zy26JeOUkQ5mRu+5o8rpsJk5+2t+Y5vE7e842qtZDQ2g1NpX/29HdyFeJ4nSIhI47ENSxlQ==} @@ -4615,6 +4724,12 @@ packages: peerDependencies: typescript: '>=4.2.0' + ts-api-utils@1.4.3: + resolution: {integrity: sha512-i3eMG77UTMD0hZhgRS562pv83RC6ukSAC2GMNWc+9dieh/+jDM5u5YG+NHX6VNDRHQcHwmsTHctP9LhbC3WxVw==} + engines: {node: '>=16'} + peerDependencies: + typescript: '>=4.2.0' + ts-command-line-args@2.5.1: resolution: {integrity: sha512-H69ZwTw3rFHb5WYpQya40YAX2/w7Ut75uUECbgBIsLmM+BNuYnxsltfyyLMxy6sEeKxgijLTnQtLd0nKd6+IYw==} hasBin: true @@ -4624,8 +4739,8 @@ packages: peerDependencies: typescript: '>=3.7.0' - ts-node@10.9.1: - resolution: {integrity: sha512-NtVysVPkxxrwFGUUxGYhfux8k78pQB3JqYBXlLRZgdGUqTO5wU/UyHop5p70iEbGhB7q5KmiZiU0Y3KlJrScEw==} + ts-node@10.9.2: + resolution: {integrity: sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==} hasBin: true peerDependencies: '@swc/core': '>=1.2.50' @@ -4641,15 +4756,11 @@ packages: tslib@1.14.1: resolution: {integrity: sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==} - tslib@2.4.0: - resolution: {integrity: sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ==} - - tslib@2.6.2: - resolution: {integrity: sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==} + tslib@2.7.0: + resolution: {integrity: sha512-gLXCKdN1/j47AiHiOkJN69hJmcbGTHI0ImLmbYLHykhgeN0jVGola9yVjFgzCUklsZQMW55o+dW7IXv3RCXDzA==} - tslog@4.9.3: - resolution: {integrity: sha512-oDWuGVONxhVEBtschLf2cs/Jy8i7h1T+CpdkTNWQgdAF7DhRo2G8vMCgILKe7ojdEkLhICWgI1LYSSKaJsRgcw==} - engines: {node: '>=16'} + tslib@2.8.1: + resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==} tsort@0.0.1: resolution: {integrity: sha512-Tyrf5mxF8Ofs1tNoxA13lFeZ2Zrbd6cKbuH3V+MQ5sb6DtBj5FjrXVsRWT8YvNAQTqNoz66dz1WsbigI22aEnw==} @@ -4759,13 +4870,8 @@ packages: typedarray@0.0.6: resolution: {integrity: sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==} - typescript@5.5.3: - resolution: {integrity: sha512-/hreyEujaB0w76zKo6717l3L0o/qEUtRgdvUBvlkhoWeOVMjMuHNHk0BRBzikzuGDqNmPQbg5ifMEqsHLiIUcQ==} - engines: {node: '>=14.17'} - hasBin: true - - typescript@5.5.4: - resolution: {integrity: sha512-Mtq29sKDAEYP7aljRgtPOpTvOfbwRWlS6dPRzwjdE+C0R4brX/GUyhHSecbHMFLNBLcJIPt9nl9yG5TZ1weH+Q==} + typescript@5.7.3: + resolution: {integrity: sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw==} engines: {node: '>=14.17'} hasBin: true @@ -4777,8 +4883,8 @@ packages: resolution: {integrity: sha512-dvdQgNDNJo+8B2uBQoqdb11eUCE1JQXhvjC/CZtgvZseVd5TYMXnq0+vuUemXbd/Se29cTaUuPX3YIc2xgbvIg==} engines: {node: '>=8'} - uglify-js@3.17.4: - resolution: {integrity: sha512-T9q82TJI9e/C1TAxYvfb16xO120tMVFZrGA3f9/P4424DNu6ypK103y0GPFVa17yotwSyZW5iYXgjYHkGrJW/g==} + uglify-js@3.19.3: + resolution: {integrity: sha512-v3Xu+yuwBXisp6QYTcH4UbH+xYJXqnq2m/LtQVWKWzYc1iehYnLixoQDN9FH6/j9/oybfd6W9Ghwkl8+UMKTKQ==} engines: {node: '>=0.8.0'} hasBin: true @@ -4788,10 +4894,17 @@ packages: undici-types@5.26.5: resolution: {integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==} + undici-types@6.19.8: + resolution: {integrity: sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==} + undici@5.28.4: resolution: {integrity: sha512-72RFADWFqKmUb2hmmvNODKL3p9hcB6Gt2DOQMis1SEBaV6a4MH8soBvzg+95CYhCKPFedut2JY9bMfrDl9D23g==} engines: {node: '>=14.0'} + undici@5.28.5: + resolution: {integrity: sha512-zICwjrDrcrUE0pyyJc1I2QzBkLM8FINsgOrt6WjA+BgajVq9Nxu2PbFFXUrAggLfDXlZGZBVZYw7WNV5KiBiBA==} + engines: {node: '>=14.0'} + undici@6.18.2: resolution: {integrity: sha512-o/MQLTwRm9IVhOqhZ0NQ9oXax1ygPjw6Vs+Vq/4QRjbOAC3B1GCHy7TYxxbExKlb7bzDRzt9vBWU6BDz0RFfYg==} engines: {node: '>=18.17'} @@ -4807,6 +4920,10 @@ packages: resolution: {integrity: sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==} engines: {node: '>= 10.0.0'} + universalify@2.0.1: + resolution: {integrity: sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==} + engines: {node: '>= 10.0.0'} + unpipe@1.0.0: resolution: {integrity: sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==} engines: {node: '>= 0.8'} @@ -4844,8 +4961,8 @@ packages: validate-npm-package-license@3.0.4: resolution: {integrity: sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==} - viem@2.19.7: - resolution: {integrity: sha512-zoaBWnI6vf7MVRn4lAbuKd25hR31088yrMqONMHU8RjHTY4nqf+O589BPODwJak1LkfpbawyGyCY2tRFwZCWgw==} + viem@2.22.10: + resolution: {integrity: sha512-amYq+bxD3k9gUx4JXzKtpKrnw1Mc3f4s32g6Axo8twpum+47r+9M2g+qh63gzrs0goTTVUsmg3n9ev+zELKRDw==} peerDependencies: typescript: '>=5.0.4' peerDependenciesMeta: @@ -4855,13 +4972,10 @@ packages: wcwidth@1.0.1: resolution: {integrity: sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg==} - web3-utils@1.10.3: - resolution: {integrity: sha512-OqcUrEE16fDBbGoQtZXWdavsPzbGIDc5v3VrRTZ0XrIpefC/viZ1ZU9bGEemazyS0catk/3rkOOxpzTfY+XsyQ==} + web3-utils@1.10.4: + resolution: {integrity: sha512-tsu8FiKJLk2PzhDl9fXbGUWTkkVXYhtTA+SmEFkKft+9BgwLxfCRpU96sWv7ICC8zixBNd3JURVoiR3dUXgP8A==} engines: {node: '>=8.0.0'} - webauthn-p256@0.0.5: - resolution: {integrity: sha512-drMGNWKdaixZNobeORVIqq7k5DsRC9FnG201K2QjeOoQLmtSDaSsVZdkg6n5jUALJKcAG++zBPJXmv6hy0nWFg==} - webidl-conversions@3.0.1: resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==} @@ -4902,6 +5016,9 @@ packages: workerpool@6.2.1: resolution: {integrity: sha512-ILEIE97kDZvF9Wb9f6h5aXK4swSlKGUcOEGiIYb2OOu/IrDU9iwj0fD//SsA6E5ibwJxpEvhullJY4Sl4GcpAw==} + workerpool@6.5.1: + resolution: {integrity: sha512-Fs4dNYcsdpYSAfVxhnl1L5zTksjvOJxtC5hzMNl+1t9B8hTJTdKDyZ5ju7ztgPy+ft9tBFXoOlDNiOT9WUXZlA==} + wrap-ansi@7.0.0: resolution: {integrity: sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==} engines: {node: '>=10'} @@ -4949,26 +5066,18 @@ packages: utf-8-validate: optional: true - ws@8.5.0: - resolution: {integrity: sha512-BWX0SWVgLPzYwF8lTzEy1egjhS4S4OEAHfsO8o65WOVsrnSRGaSiUaa9e0ggGlkMTtBlmOpEXiie9RUcBO86qg==} + ws@8.18.0: + resolution: {integrity: sha512-8VbfWfHLbbwu3+N6OKsOMpBdT4kXPDDB9cJk2bJ6mh9ucxdlnNvH1e+roYkKmN9Nxw2yjz7VzeO9oOz2zJ04Pw==} engines: {node: '>=10.0.0'} peerDependencies: bufferutil: ^4.0.1 - utf-8-validate: ^5.0.2 + utf-8-validate: '>=5.0.2' peerDependenciesMeta: bufferutil: optional: true utf-8-validate: optional: true - xdeployer@2.1.13: - resolution: {integrity: sha512-QxVsQ+zz+cnhzCIs7/e5F06nKjOD2Lb47nW52Jw3IzFQVeYv6NfvokhZiez+y8jkzwvHDwVru+fCVlml0GQGkw==} - engines: {node: '>=14.0.0'} - peerDependencies: - '@nomicfoundation/hardhat-ethers': ^3.0.4 - ethers: ^6.8.1 - hardhat: ^2.19.0 - y18n@5.0.8: resolution: {integrity: sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==} engines: {node: '>=10'} @@ -5015,11 +5124,6 @@ packages: resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==} engines: {node: '>=10'} - zksync-web3@0.14.4: - resolution: {integrity: sha512-kYehMD/S6Uhe1g434UnaMN+sBr9nQm23Ywn0EUP5BfQCsbjcr3ORuS68PosZw8xUTu3pac7G6YMSnNHk+fwzvg==} - peerDependencies: - ethers: ^5.7.0 - zod@3.23.8: resolution: {integrity: sha512-XBx9AXhXktjUqnepgTiE5flcKIYWi/rme0Eaj+5Y0lftuGBq+jyRu/md4WnuxqgP1ubdpNCsYEYPxrzVHD8d6g==} @@ -5027,10 +5131,10 @@ snapshots: '@aashutoshrathi/word-wrap@1.2.6': {} - '@adraffy/ens-normalize@1.10.0': {} - '@adraffy/ens-normalize@1.10.1': {} + '@adraffy/ens-normalize@1.11.0': {} + '@ampproject/remapping@2.2.1': dependencies: '@jridgewell/gen-mapping': 0.3.3 @@ -5040,7 +5144,7 @@ snapshots: dependencies: '@aws-crypto/util': 5.2.0 '@aws-sdk/types': 3.731.0 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-crypto/sha256-browser@5.2.0': dependencies: @@ -5050,7 +5154,7 @@ snapshots: '@aws-sdk/types': 3.731.0 '@aws-sdk/util-locate-window': 3.723.0 '@smithy/util-utf8': 2.3.0 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-crypto/sha256-js@1.2.2': dependencies: @@ -5062,11 +5166,11 @@ snapshots: dependencies: '@aws-crypto/util': 5.2.0 '@aws-sdk/types': 3.731.0 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-crypto/supports-web-crypto@5.2.0': dependencies: - tslib: 2.6.2 + tslib: 2.8.1 '@aws-crypto/util@1.2.2': dependencies: @@ -5078,7 +5182,7 @@ snapshots: dependencies: '@aws-sdk/types': 3.731.0 '@smithy/util-utf8': 2.3.0 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-sdk/client-lambda@3.731.1': dependencies: @@ -5125,7 +5229,7 @@ snapshots: '@smithy/util-stream': 4.0.2 '@smithy/util-utf8': 4.0.0 '@smithy/util-waiter': 4.0.2 - tslib: 2.6.2 + tslib: 2.8.1 transitivePeerDependencies: - aws-crt @@ -5168,7 +5272,7 @@ snapshots: '@smithy/util-middleware': 4.0.1 '@smithy/util-retry': 4.0.1 '@smithy/util-utf8': 4.0.0 - tslib: 2.6.2 + tslib: 2.8.1 transitivePeerDependencies: - aws-crt @@ -5184,7 +5288,7 @@ snapshots: '@smithy/types': 4.1.0 '@smithy/util-middleware': 4.0.1 fast-xml-parser: 4.4.1 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-sdk/credential-provider-env@3.731.0': dependencies: @@ -5192,7 +5296,7 @@ snapshots: '@aws-sdk/types': 3.731.0 '@smithy/property-provider': 4.0.1 '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-sdk/credential-provider-http@3.731.0': dependencies: @@ -5205,7 +5309,7 @@ snapshots: '@smithy/smithy-client': 4.1.2 '@smithy/types': 4.1.0 '@smithy/util-stream': 4.0.2 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-sdk/credential-provider-ini@3.731.1': dependencies: @@ -5221,7 +5325,7 @@ snapshots: '@smithy/property-provider': 4.0.1 '@smithy/shared-ini-file-loader': 4.0.1 '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 transitivePeerDependencies: - aws-crt @@ -5238,7 +5342,7 @@ snapshots: '@smithy/property-provider': 4.0.1 '@smithy/shared-ini-file-loader': 4.0.1 '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 transitivePeerDependencies: - aws-crt @@ -5249,7 +5353,7 @@ snapshots: '@smithy/property-provider': 4.0.1 '@smithy/shared-ini-file-loader': 4.0.1 '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-sdk/credential-provider-sso@3.731.1': dependencies: @@ -5260,7 +5364,7 @@ snapshots: '@smithy/property-provider': 4.0.1 '@smithy/shared-ini-file-loader': 4.0.1 '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 transitivePeerDependencies: - aws-crt @@ -5271,7 +5375,7 @@ snapshots: '@aws-sdk/types': 3.731.0 '@smithy/property-provider': 4.0.1 '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 transitivePeerDependencies: - aws-crt @@ -5280,20 +5384,20 @@ snapshots: '@aws-sdk/types': 3.731.0 '@smithy/protocol-http': 5.0.1 '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-sdk/middleware-logger@3.731.0': dependencies: '@aws-sdk/types': 3.731.0 '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-sdk/middleware-recursion-detection@3.731.0': dependencies: '@aws-sdk/types': 3.731.0 '@smithy/protocol-http': 5.0.1 '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-sdk/middleware-user-agent@3.731.0': dependencies: @@ -5303,7 +5407,7 @@ snapshots: '@smithy/core': 3.1.1 '@smithy/protocol-http': 5.0.1 '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-sdk/nested-clients@3.731.1': dependencies: @@ -5344,7 +5448,7 @@ snapshots: '@smithy/util-middleware': 4.0.1 '@smithy/util-retry': 4.0.1 '@smithy/util-utf8': 4.0.0 - tslib: 2.6.2 + tslib: 2.8.1 transitivePeerDependencies: - aws-crt @@ -5355,7 +5459,7 @@ snapshots: '@smithy/types': 4.1.0 '@smithy/util-config-provider': 4.0.0 '@smithy/util-middleware': 4.0.1 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-sdk/token-providers@3.731.1': dependencies: @@ -5364,37 +5468,37 @@ snapshots: '@smithy/property-provider': 4.0.1 '@smithy/shared-ini-file-loader': 4.0.1 '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 transitivePeerDependencies: - aws-crt '@aws-sdk/types@3.433.0': dependencies: '@smithy/types': 2.4.0 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-sdk/types@3.731.0': dependencies: '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-sdk/util-endpoints@3.731.0': dependencies: '@aws-sdk/types': 3.731.0 '@smithy/types': 4.1.0 '@smithy/util-endpoints': 3.0.1 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-sdk/util-locate-window@3.723.0': dependencies: - tslib: 2.6.2 + tslib: 2.8.1 '@aws-sdk/util-user-agent-browser@3.731.0': dependencies: '@aws-sdk/types': 3.731.0 '@smithy/types': 4.1.0 bowser: 2.11.0 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-sdk/util-user-agent-node@3.731.0': dependencies: @@ -5402,11 +5506,11 @@ snapshots: '@aws-sdk/types': 3.731.0 '@smithy/node-config-provider': 4.0.1 '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@aws-sdk/util-utf8-browser@3.259.0': dependencies: - tslib: 2.6.2 + tslib: 2.8.1 '@babel/code-frame@7.23.5': dependencies: @@ -5582,9 +5686,9 @@ snapshots: '@bytecodealliance/preview2-shim@0.17.0': {} - '@chainlink/contracts@0.8.0(bufferutil@4.0.8)(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10)': + '@chainlink/contracts@0.8.0(bufferutil@4.0.8)(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10)': dependencies: - '@eth-optimism/contracts': 0.5.40(bufferutil@4.0.8)(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10) + '@eth-optimism/contracts': 0.5.40(bufferutil@4.0.8)(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10) '@openzeppelin/contracts': 4.3.3 '@openzeppelin/contracts-upgradeable-4.7.3': '@openzeppelin/contracts-upgradeable@4.7.3' '@openzeppelin/contracts-v0.7': '@openzeppelin/contracts@3.4.2' @@ -5593,9 +5697,6 @@ snapshots: - ethers - utf-8-validate - '@colors/colors@1.5.0': - optional: true - '@commitlint/cli@17.8.1(@swc/core@1.6.3)': dependencies: '@commitlint/format': 17.8.1 @@ -5624,7 +5725,7 @@ snapshots: '@commitlint/config-validator@18.1.0': dependencies: '@commitlint/types': 18.1.0 - ajv: 8.12.0 + ajv: 8.17.1 optional: true '@commitlint/ensure@17.8.1': @@ -5666,28 +5767,28 @@ snapshots: '@commitlint/types': 17.8.1 '@types/node': 20.5.1 chalk: 4.1.2 - cosmiconfig: 8.3.6(typescript@5.5.3) - cosmiconfig-typescript-loader: 4.4.0(@types/node@20.5.1)(cosmiconfig@8.3.6(typescript@5.5.3))(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@20.5.1)(typescript@5.5.3))(typescript@5.5.3) + cosmiconfig: 8.3.6(typescript@5.7.3) + cosmiconfig-typescript-loader: 4.4.0(@types/node@20.5.1)(cosmiconfig@8.3.6(typescript@5.7.3))(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@20.5.1)(typescript@5.7.3))(typescript@5.7.3) lodash.isplainobject: 4.0.6 lodash.merge: 4.6.2 lodash.uniq: 4.5.0 resolve-from: 5.0.0 - ts-node: 10.9.1(@swc/core@1.6.3)(@types/node@20.5.1)(typescript@5.5.3) - typescript: 5.5.3 + ts-node: 10.9.2(@swc/core@1.6.3)(@types/node@20.5.1)(typescript@5.7.3) + typescript: 5.7.3 transitivePeerDependencies: - '@swc/core' - '@swc/wasm' - '@commitlint/load@18.2.0(typescript@5.5.3)': + '@commitlint/load@18.2.0(typescript@5.7.3)': dependencies: '@commitlint/config-validator': 18.1.0 '@commitlint/execute-rule': 18.1.0 '@commitlint/resolve-extends': 18.1.0 '@commitlint/types': 18.1.0 - '@types/node': 18.18.7 + '@types/node': 18.19.71 chalk: 4.1.2 - cosmiconfig: 8.3.6(typescript@5.5.3) - cosmiconfig-typescript-loader: 5.0.0(@types/node@18.18.7)(cosmiconfig@8.3.6(typescript@5.5.3))(typescript@5.5.3) + cosmiconfig: 8.3.6(typescript@5.7.3) + cosmiconfig-typescript-loader: 5.0.0(@types/node@18.19.71)(cosmiconfig@8.3.6(typescript@5.7.3))(typescript@5.7.3) lodash.isplainobject: 4.0.6 lodash.merge: 4.6.2 lodash.uniq: 4.5.0 @@ -5827,14 +5928,19 @@ snapshots: '@esbuild/win32-x64@0.21.5': optional: true - '@eslint-community/eslint-utils@4.4.0(eslint@8.52.0)': + '@eslint-community/eslint-utils@4.4.0(eslint@8.57.1)': + dependencies: + eslint: 8.57.1 + eslint-visitor-keys: 3.4.3 + + '@eslint-community/eslint-utils@4.4.1(eslint@8.57.1)': dependencies: - eslint: 8.52.0 + eslint: 8.57.1 eslint-visitor-keys: 3.4.3 '@eslint-community/regexpp@4.10.0': {} - '@eslint/eslintrc@2.1.2': + '@eslint/eslintrc@2.1.4': dependencies: ajv: 6.12.6 debug: 4.3.4(supports-color@8.1.1) @@ -5848,14 +5954,14 @@ snapshots: transitivePeerDependencies: - supports-color - '@eslint/js@8.52.0': {} + '@eslint/js@8.57.1': {} - '@eth-optimism/contracts@0.5.40(bufferutil@4.0.8)(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10)': + '@eth-optimism/contracts@0.5.40(bufferutil@4.0.8)(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10)': dependencies: '@eth-optimism/core-utils': 0.12.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) '@ethersproject/abstract-provider': 5.7.0 '@ethersproject/abstract-signer': 5.7.0 - ethers: 6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) + ethers: 6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10) transitivePeerDependencies: - bufferutil - utf-8-validate @@ -5887,7 +5993,7 @@ snapshots: '@ethereumjs/util@8.1.0': dependencies: '@ethereumjs/rlp': 4.0.1 - ethereum-cryptography: 2.1.2 + ethereum-cryptography: 2.2.1 micro-ftch: 0.3.1 '@ethersproject/abi@5.7.0': @@ -6155,11 +6261,13 @@ snapshots: '@fastify/busboy@2.0.0': {} + '@fastify/busboy@2.1.1': {} + '@fastify/deepmerge@1.3.0': {} - '@humanwhocodes/config-array@0.11.13': + '@humanwhocodes/config-array@0.13.0': dependencies: - '@humanwhocodes/object-schema': 2.0.1 + '@humanwhocodes/object-schema': 2.0.3 debug: 4.3.4(supports-color@8.1.1) minimatch: 3.1.2 transitivePeerDependencies: @@ -6167,7 +6275,7 @@ snapshots: '@humanwhocodes/module-importer@1.0.1': {} - '@humanwhocodes/object-schema@2.0.1': {} + '@humanwhocodes/object-schema@2.0.3': {} '@isaacs/cliui@8.0.2': dependencies: @@ -6210,26 +6318,30 @@ snapshots: tweetnacl: 1.0.3 tweetnacl-util: 0.15.1 - '@noble/curves@1.1.0': - dependencies: - '@noble/hashes': 1.3.1 - '@noble/curves@1.2.0': dependencies: '@noble/hashes': 1.3.2 - '@noble/curves@1.4.0': + '@noble/curves@1.4.2': dependencies: '@noble/hashes': 1.4.0 - '@noble/hashes@1.2.0': {} + '@noble/curves@1.7.0': + dependencies: + '@noble/hashes': 1.6.0 - '@noble/hashes@1.3.1': {} + '@noble/hashes@1.2.0': {} '@noble/hashes@1.3.2': {} '@noble/hashes@1.4.0': {} + '@noble/hashes@1.6.0': {} + + '@noble/hashes@1.6.1': {} + + '@noble/hashes@1.7.1': {} + '@noble/secp256k1@1.7.1': {} '@nodelib/fs.scandir@2.1.5': @@ -6288,96 +6400,96 @@ snapshots: '@nomicfoundation/ethereumjs-rlp': 5.0.4 ethereum-cryptography: 0.1.3 - '@nomicfoundation/hardhat-chai-matchers@2.0.7(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(chai@4.5.0)(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))': + '@nomicfoundation/hardhat-chai-matchers@2.0.7(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(chai@4.5.0)(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10))': dependencies: - '@nomicfoundation/hardhat-ethers': 3.0.8(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)) - '@types/chai-as-promised': 7.1.7 + '@nomicfoundation/hardhat-ethers': 3.0.8(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)) + '@types/chai-as-promised': 7.1.8 chai: 4.5.0 - chai-as-promised: 7.1.1(chai@4.5.0) - deep-eql: 4.1.3 - ethers: 6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) - hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10) + chai-as-promised: 7.1.2(chai@4.5.0) + deep-eql: 4.1.4 + ethers: 6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10) + hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10) ordinal: 1.0.3 - '@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))': + '@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10))': dependencies: debug: 4.3.4(supports-color@8.1.1) - ethers: 6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) - hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10) + ethers: 6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10) + hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10) lodash.isequal: 4.5.0 transitivePeerDependencies: - supports-color - '@nomicfoundation/hardhat-ignition-ethers@0.15.4(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-ignition@0.15.5(@nomicfoundation/hardhat-verify@2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(bufferutil@4.0.8)(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10))(@nomicfoundation/ignition-core@0.15.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))': + '@nomicfoundation/hardhat-ignition-ethers@0.15.4(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-ignition@0.15.5(@nomicfoundation/hardhat-verify@2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(bufferutil@4.0.8)(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10))(@nomicfoundation/ignition-core@0.15.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10))': dependencies: - '@nomicfoundation/hardhat-ethers': 3.0.8(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)) - '@nomicfoundation/hardhat-ignition': 0.15.5(@nomicfoundation/hardhat-verify@2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(bufferutil@4.0.8)(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10) + '@nomicfoundation/hardhat-ethers': 3.0.8(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)) + '@nomicfoundation/hardhat-ignition': 0.15.5(@nomicfoundation/hardhat-verify@2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(bufferutil@4.0.8)(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10) '@nomicfoundation/ignition-core': 0.15.5(bufferutil@4.0.8)(utf-8-validate@5.0.10) - ethers: 6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) - hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10) + ethers: 6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10) + hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10) - '@nomicfoundation/hardhat-ignition@0.15.5(@nomicfoundation/hardhat-verify@2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(bufferutil@4.0.8)(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10)': + '@nomicfoundation/hardhat-ignition@0.15.5(@nomicfoundation/hardhat-verify@2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(bufferutil@4.0.8)(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10)': dependencies: - '@nomicfoundation/hardhat-verify': 2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)) + '@nomicfoundation/hardhat-verify': 2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)) '@nomicfoundation/ignition-core': 0.15.5(bufferutil@4.0.8)(utf-8-validate@5.0.10) - '@nomicfoundation/ignition-ui': 0.15.5 + '@nomicfoundation/ignition-ui': 0.15.9 chalk: 4.1.2 - debug: 4.3.4(supports-color@8.1.1) + debug: 4.4.0(supports-color@8.1.1) fs-extra: 10.1.0 - hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10) + hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10) prompts: 2.4.2 transitivePeerDependencies: - bufferutil - supports-color - utf-8-validate - '@nomicfoundation/hardhat-network-helpers@1.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))': + '@nomicfoundation/hardhat-network-helpers@1.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10))': dependencies: ethereumjs-util: 7.1.5 - hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10) + hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10) - ? '@nomicfoundation/hardhat-toolbox@5.0.0(@nomicfoundation/hardhat-chai-matchers@2.0.7(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(chai@4.5.0)(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-ignition-ethers@0.15.4(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-ignition@0.15.5(@nomicfoundation/hardhat-verify@2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(bufferutil@4.0.8)(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10))(@nomicfoundation/ignition-core@0.15.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-network-helpers@1.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-verify@2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(@typechain/ethers-v6@0.4.3(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.5.3))(typescript@5.5.3))(@typechain/hardhat@9.1.0(@typechain/ethers-v6@0.4.3(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.5.3))(typescript@5.5.3))(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.5.3)))(@types/chai@4.3.11)(@types/mocha@9.1.0)(@types/node@18.18.7)(chai@4.5.0)(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat-gas-reporter@1.0.9(bufferutil@4.0.8)(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))(solidity-coverage@0.8.5(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typechain@8.3.2(typescript@5.5.3))(typescript@5.5.3)' + ? '@nomicfoundation/hardhat-toolbox@5.0.0(@nomicfoundation/hardhat-chai-matchers@2.0.7(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(chai@4.5.0)(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-ignition-ethers@0.15.4(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-ignition@0.15.5(@nomicfoundation/hardhat-verify@2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(bufferutil@4.0.8)(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10))(@nomicfoundation/ignition-core@0.15.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-network-helpers@1.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-verify@2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(@typechain/ethers-v6@0.4.3(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.7.3))(typescript@5.7.3))(@typechain/hardhat@9.1.0(@typechain/ethers-v6@0.4.3(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.7.3))(typescript@5.7.3))(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.7.3)))(@types/chai@4.3.11)(@types/mocha@9.1.0)(@types/node@18.19.71)(chai@4.5.0)(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat-gas-reporter@1.0.9(bufferutil@4.0.8)(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10))(solidity-coverage@0.8.5(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typechain@8.3.2(typescript@5.7.3))(typescript@5.7.3)' : dependencies: - '@nomicfoundation/hardhat-chai-matchers': 2.0.7(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(chai@4.5.0)(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)) - '@nomicfoundation/hardhat-ethers': 3.0.8(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)) - '@nomicfoundation/hardhat-ignition-ethers': 0.15.4(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-ignition@0.15.5(@nomicfoundation/hardhat-verify@2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(bufferutil@4.0.8)(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10))(@nomicfoundation/ignition-core@0.15.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)) - '@nomicfoundation/hardhat-network-helpers': 1.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)) - '@nomicfoundation/hardhat-verify': 2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)) - '@typechain/ethers-v6': 0.4.3(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.5.3))(typescript@5.5.3) - '@typechain/hardhat': 9.1.0(@typechain/ethers-v6@0.4.3(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.5.3))(typescript@5.5.3))(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.5.3)) + '@nomicfoundation/hardhat-chai-matchers': 2.0.7(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(chai@4.5.0)(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)) + '@nomicfoundation/hardhat-ethers': 3.0.8(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)) + '@nomicfoundation/hardhat-ignition-ethers': 0.15.4(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-ignition@0.15.5(@nomicfoundation/hardhat-verify@2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(bufferutil@4.0.8)(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10))(@nomicfoundation/ignition-core@0.15.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)) + '@nomicfoundation/hardhat-network-helpers': 1.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)) + '@nomicfoundation/hardhat-verify': 2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)) + '@typechain/ethers-v6': 0.4.3(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.7.3))(typescript@5.7.3) + '@typechain/hardhat': 9.1.0(@typechain/ethers-v6@0.4.3(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.7.3))(typescript@5.7.3))(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.7.3)) '@types/chai': 4.3.11 '@types/mocha': 9.1.0 - '@types/node': 18.18.7 + '@types/node': 18.19.71 chai: 4.5.0 - ethers: 6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) - hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10) - hardhat-gas-reporter: 1.0.9(bufferutil@4.0.8)(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10) - solidity-coverage: 0.8.5(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)) - ts-node: 10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3) - typechain: 8.3.2(typescript@5.5.3) - typescript: 5.5.3 + ethers: 6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10) + hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10) + hardhat-gas-reporter: 1.0.9(bufferutil@4.0.8)(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10) + solidity-coverage: 0.8.5(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)) + ts-node: 10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3) + typechain: 8.3.2(typescript@5.7.3) + typescript: 5.7.3 - '@nomicfoundation/hardhat-verify@2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))': + '@nomicfoundation/hardhat-verify@2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10))': dependencies: '@ethersproject/abi': 5.7.0 '@ethersproject/address': 5.7.0 cbor: 8.1.0 chalk: 2.4.2 - debug: 4.3.4(supports-color@8.1.1) - hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10) + debug: 4.4.0(supports-color@8.1.1) + hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10) lodash.clonedeep: 4.5.0 semver: 6.3.1 - table: 6.8.1 - undici: 5.28.4 + table: 6.9.0 + undici: 5.28.5 transitivePeerDependencies: - supports-color - '@nomicfoundation/hardhat-viem@2.0.6(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))(typescript@5.5.3)(viem@2.19.7(bufferutil@4.0.8)(typescript@5.5.3)(utf-8-validate@5.0.10)(zod@3.23.8))(zod@3.23.8)': + '@nomicfoundation/hardhat-viem@2.0.6(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10))(typescript@5.7.3)(viem@2.22.10(bufferutil@4.0.8)(typescript@5.7.3)(utf-8-validate@5.0.10)(zod@3.23.8))(zod@3.23.8)': dependencies: - abitype: 0.9.8(typescript@5.5.3)(zod@3.23.8) - hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10) + abitype: 0.9.8(typescript@5.7.3)(zod@3.23.8) + hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10) lodash.memoize: 4.1.2 - viem: 2.19.7(bufferutil@4.0.8)(typescript@5.5.3)(utf-8-validate@5.0.10)(zod@3.23.8) + viem: 2.22.10(bufferutil@4.0.8)(typescript@5.7.3)(utf-8-validate@5.0.10)(zod@3.23.8) transitivePeerDependencies: - typescript - zod @@ -6385,10 +6497,10 @@ snapshots: '@nomicfoundation/ignition-core@0.15.5(bufferutil@4.0.8)(utf-8-validate@5.0.10)': dependencies: '@ethersproject/address': 5.6.1 - '@nomicfoundation/solidity-analyzer': 0.1.1 - cbor: 9.0.1 - debug: 4.3.4(supports-color@8.1.1) - ethers: 6.13.1(bufferutil@4.0.8)(utf-8-validate@5.0.10) + '@nomicfoundation/solidity-analyzer': 0.1.2 + cbor: 9.0.2 + debug: 4.4.0(supports-color@8.1.1) + ethers: 6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10) fs-extra: 10.1.0 immer: 10.0.2 lodash: 4.17.21 @@ -6398,37 +6510,7 @@ snapshots: - supports-color - utf-8-validate - '@nomicfoundation/ignition-ui@0.15.5': {} - - '@nomicfoundation/slang-darwin-arm64@0.15.1': {} - - '@nomicfoundation/slang-darwin-x64@0.15.1': {} - - '@nomicfoundation/slang-linux-arm64-gnu@0.15.1': {} - - '@nomicfoundation/slang-linux-arm64-musl@0.15.1': {} - - '@nomicfoundation/slang-linux-x64-gnu@0.15.1': {} - - '@nomicfoundation/slang-linux-x64-musl@0.15.1': {} - - '@nomicfoundation/slang-win32-arm64-msvc@0.15.1': {} - - '@nomicfoundation/slang-win32-ia32-msvc@0.15.1': {} - - '@nomicfoundation/slang-win32-x64-msvc@0.15.1': {} - - '@nomicfoundation/slang@0.15.1': - dependencies: - '@nomicfoundation/slang-darwin-arm64': 0.15.1 - '@nomicfoundation/slang-darwin-x64': 0.15.1 - '@nomicfoundation/slang-linux-arm64-gnu': 0.15.1 - '@nomicfoundation/slang-linux-arm64-musl': 0.15.1 - '@nomicfoundation/slang-linux-x64-gnu': 0.15.1 - '@nomicfoundation/slang-linux-x64-musl': 0.15.1 - '@nomicfoundation/slang-win32-arm64-msvc': 0.15.1 - '@nomicfoundation/slang-win32-ia32-msvc': 0.15.1 - '@nomicfoundation/slang-win32-x64-msvc': 0.15.1 + '@nomicfoundation/ignition-ui@0.15.9': {} '@nomicfoundation/slang@0.18.3': dependencies: @@ -6437,24 +6519,42 @@ snapshots: '@nomicfoundation/solidity-analyzer-darwin-arm64@0.1.1': optional: true + '@nomicfoundation/solidity-analyzer-darwin-arm64@0.1.2': + optional: true + '@nomicfoundation/solidity-analyzer-darwin-x64@0.1.1': optional: true + '@nomicfoundation/solidity-analyzer-darwin-x64@0.1.2': + optional: true + '@nomicfoundation/solidity-analyzer-freebsd-x64@0.1.1': optional: true '@nomicfoundation/solidity-analyzer-linux-arm64-gnu@0.1.1': optional: true + '@nomicfoundation/solidity-analyzer-linux-arm64-gnu@0.1.2': + optional: true + '@nomicfoundation/solidity-analyzer-linux-arm64-musl@0.1.1': optional: true + '@nomicfoundation/solidity-analyzer-linux-arm64-musl@0.1.2': + optional: true + '@nomicfoundation/solidity-analyzer-linux-x64-gnu@0.1.1': optional: true + '@nomicfoundation/solidity-analyzer-linux-x64-gnu@0.1.2': + optional: true + '@nomicfoundation/solidity-analyzer-linux-x64-musl@0.1.1': optional: true + '@nomicfoundation/solidity-analyzer-linux-x64-musl@0.1.2': + optional: true + '@nomicfoundation/solidity-analyzer-win32-arm64-msvc@0.1.1': optional: true @@ -6464,6 +6564,9 @@ snapshots: '@nomicfoundation/solidity-analyzer-win32-x64-msvc@0.1.1': optional: true + '@nomicfoundation/solidity-analyzer-win32-x64-msvc@0.1.2': + optional: true + '@nomicfoundation/solidity-analyzer@0.1.1': optionalDependencies: '@nomicfoundation/solidity-analyzer-darwin-arm64': 0.1.1 @@ -6477,6 +6580,16 @@ snapshots: '@nomicfoundation/solidity-analyzer-win32-ia32-msvc': 0.1.1 '@nomicfoundation/solidity-analyzer-win32-x64-msvc': 0.1.1 + '@nomicfoundation/solidity-analyzer@0.1.2': + optionalDependencies: + '@nomicfoundation/solidity-analyzer-darwin-arm64': 0.1.2 + '@nomicfoundation/solidity-analyzer-darwin-x64': 0.1.2 + '@nomicfoundation/solidity-analyzer-linux-arm64-gnu': 0.1.2 + '@nomicfoundation/solidity-analyzer-linux-arm64-musl': 0.1.2 + '@nomicfoundation/solidity-analyzer-linux-x64-gnu': 0.1.2 + '@nomicfoundation/solidity-analyzer-linux-x64-musl': 0.1.2 + '@nomicfoundation/solidity-analyzer-win32-x64-msvc': 0.1.2 + '@openzeppelin/contracts-upgradeable@4.7.3': {} '@openzeppelin/contracts@3.4.2': {} @@ -6514,9 +6627,9 @@ snapshots: - debug - encoding - '@openzeppelin/hardhat-upgrades@3.9.0(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-verify@2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(encoding@0.1.13)(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))': + '@openzeppelin/hardhat-upgrades@3.9.0(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-verify@2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)))(encoding@0.1.13)(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10))': dependencies: - '@nomicfoundation/hardhat-ethers': 3.0.8(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)) + '@nomicfoundation/hardhat-ethers': 3.0.8(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)) '@openzeppelin/defender-sdk-base-client': 2.1.0(encoding@0.1.13) '@openzeppelin/defender-sdk-deploy-client': 2.1.0(debug@4.3.4)(encoding@0.1.13) '@openzeppelin/defender-sdk-network-client': 2.1.0(debug@4.3.4)(encoding@0.1.13) @@ -6524,31 +6637,17 @@ snapshots: chalk: 4.1.2 debug: 4.3.4(supports-color@8.1.1) ethereumjs-util: 7.1.5 - ethers: 6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) - hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10) + ethers: 6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10) + hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10) proper-lockfile: 4.1.2 undici: 6.18.2 optionalDependencies: - '@nomicfoundation/hardhat-verify': 2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)) + '@nomicfoundation/hardhat-verify': 2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)) transitivePeerDependencies: - aws-crt - encoding - supports-color - '@openzeppelin/upgrades-core@1.35.1': - dependencies: - '@nomicfoundation/slang': 0.15.1 - cbor: 9.0.1 - chalk: 4.1.2 - compare-versions: 6.1.0 - debug: 4.3.4(supports-color@8.1.1) - ethereumjs-util: 7.1.5 - minimist: 1.2.8 - proper-lockfile: 4.1.2 - solidity-ast: 0.4.52 - transitivePeerDependencies: - - supports-color - '@openzeppelin/upgrades-core@1.41.0': dependencies: '@nomicfoundation/slang': 0.18.3 @@ -6567,125 +6666,157 @@ snapshots: '@pkgjs/parseargs@0.11.0': optional: true - '@primitivefi/hardhat-dodoc@0.2.3(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))(squirrelly@8.0.8)': + '@primitivefi/hardhat-dodoc@0.2.3(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10))(squirrelly@8.0.8)': dependencies: - hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10) + hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10) squirrelly: 8.0.8 - '@rollup/plugin-commonjs@24.1.0(rollup@4.6.1)': + '@rollup/plugin-commonjs@24.1.0(rollup@4.31.0)': dependencies: - '@rollup/pluginutils': 5.0.5(rollup@4.6.1) + '@rollup/pluginutils': 5.0.5(rollup@4.31.0) commondir: 1.0.1 estree-walker: 2.0.2 glob: 8.1.0 is-reference: 1.2.1 magic-string: 0.27.0 optionalDependencies: - rollup: 4.6.1 + rollup: 4.31.0 - '@rollup/plugin-json@6.0.1(rollup@4.6.1)': + '@rollup/plugin-json@6.1.0(rollup@4.31.0)': dependencies: - '@rollup/pluginutils': 5.0.5(rollup@4.6.1) + '@rollup/pluginutils': 5.1.4(rollup@4.31.0) optionalDependencies: - rollup: 4.6.1 + rollup: 4.31.0 - '@rollup/plugin-node-resolve@15.2.3(rollup@4.6.1)': + '@rollup/plugin-node-resolve@15.3.1(rollup@4.31.0)': dependencies: - '@rollup/pluginutils': 5.0.5(rollup@4.6.1) + '@rollup/pluginutils': 5.0.5(rollup@4.31.0) '@types/resolve': 1.20.2 deepmerge: 4.3.1 - is-builtin-module: 3.2.1 is-module: 1.0.0 resolve: 1.22.8 optionalDependencies: - rollup: 4.6.1 + rollup: 4.31.0 - '@rollup/pluginutils@5.0.5(rollup@4.6.1)': + '@rollup/pluginutils@5.0.5(rollup@4.31.0)': dependencies: '@types/estree': 1.0.3 estree-walker: 2.0.2 picomatch: 2.3.1 optionalDependencies: - rollup: 4.6.1 + rollup: 4.31.0 - '@rollup/pluginutils@5.1.0(rollup@4.6.1)': + '@rollup/pluginutils@5.1.0(rollup@4.31.0)': dependencies: '@types/estree': 1.0.5 estree-walker: 2.0.2 picomatch: 2.3.1 optionalDependencies: - rollup: 4.6.1 + rollup: 4.31.0 - '@rollup/rollup-android-arm-eabi@4.6.1': + '@rollup/pluginutils@5.1.4(rollup@4.31.0)': + dependencies: + '@types/estree': 1.0.6 + estree-walker: 2.0.2 + picomatch: 4.0.2 + optionalDependencies: + rollup: 4.31.0 + + '@rollup/rollup-android-arm-eabi@4.31.0': + optional: true + + '@rollup/rollup-android-arm64@4.31.0': + optional: true + + '@rollup/rollup-darwin-arm64@4.31.0': + optional: true + + '@rollup/rollup-darwin-x64@4.31.0': + optional: true + + '@rollup/rollup-freebsd-arm64@4.31.0': + optional: true + + '@rollup/rollup-freebsd-x64@4.31.0': + optional: true + + '@rollup/rollup-linux-arm-gnueabihf@4.31.0': + optional: true + + '@rollup/rollup-linux-arm-musleabihf@4.31.0': optional: true - '@rollup/rollup-android-arm64@4.6.1': + '@rollup/rollup-linux-arm64-gnu@4.31.0': optional: true - '@rollup/rollup-darwin-arm64@4.6.1': + '@rollup/rollup-linux-arm64-musl@4.31.0': optional: true - '@rollup/rollup-darwin-x64@4.6.1': + '@rollup/rollup-linux-loongarch64-gnu@4.31.0': optional: true - '@rollup/rollup-linux-arm-gnueabihf@4.6.1': + '@rollup/rollup-linux-powerpc64le-gnu@4.31.0': optional: true - '@rollup/rollup-linux-arm64-gnu@4.6.1': + '@rollup/rollup-linux-riscv64-gnu@4.31.0': optional: true - '@rollup/rollup-linux-arm64-musl@4.6.1': + '@rollup/rollup-linux-s390x-gnu@4.31.0': optional: true - '@rollup/rollup-linux-x64-gnu@4.6.1': + '@rollup/rollup-linux-x64-gnu@4.31.0': optional: true - '@rollup/rollup-linux-x64-musl@4.6.1': + '@rollup/rollup-linux-x64-musl@4.31.0': optional: true - '@rollup/rollup-win32-arm64-msvc@4.6.1': + '@rollup/rollup-win32-arm64-msvc@4.31.0': optional: true - '@rollup/rollup-win32-ia32-msvc@4.6.1': + '@rollup/rollup-win32-ia32-msvc@4.31.0': optional: true - '@rollup/rollup-win32-x64-msvc@4.6.1': + '@rollup/rollup-win32-x64-msvc@4.31.0': optional: true '@scure/base@1.1.7': {} + '@scure/base@1.1.9': {} + + '@scure/base@1.2.4': {} + '@scure/bip32@1.1.5': dependencies: '@noble/hashes': 1.2.0 '@noble/secp256k1': 1.7.1 '@scure/base': 1.1.7 - '@scure/bip32@1.3.1': - dependencies: - '@noble/curves': 1.1.0 - '@noble/hashes': 1.3.2 - '@scure/base': 1.1.7 - '@scure/bip32@1.4.0': dependencies: - '@noble/curves': 1.4.0 + '@noble/curves': 1.4.2 '@noble/hashes': 1.4.0 - '@scure/base': 1.1.7 + '@scure/base': 1.1.9 - '@scure/bip39@1.1.1': + '@scure/bip32@1.6.0': dependencies: - '@noble/hashes': 1.2.0 - '@scure/base': 1.1.7 + '@noble/curves': 1.7.0 + '@noble/hashes': 1.6.1 + '@scure/base': 1.2.4 - '@scure/bip39@1.2.1': + '@scure/bip39@1.1.1': dependencies: - '@noble/hashes': 1.3.2 + '@noble/hashes': 1.2.0 '@scure/base': 1.1.7 '@scure/bip39@1.3.0': dependencies: '@noble/hashes': 1.4.0 - '@scure/base': 1.1.7 + '@scure/base': 1.1.9 + + '@scure/bip39@1.5.0': + dependencies: + '@noble/hashes': 1.6.1 + '@scure/base': 1.2.4 '@sentry/core@5.30.0': dependencies: @@ -6739,7 +6870,7 @@ snapshots: '@smithy/abort-controller@4.0.1': dependencies: '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/config-resolver@4.0.1': dependencies: @@ -6747,7 +6878,7 @@ snapshots: '@smithy/types': 4.1.0 '@smithy/util-config-provider': 4.0.0 '@smithy/util-middleware': 4.0.1 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/core@3.1.1': dependencies: @@ -6758,7 +6889,7 @@ snapshots: '@smithy/util-middleware': 4.0.1 '@smithy/util-stream': 4.0.2 '@smithy/util-utf8': 4.0.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/credential-provider-imds@4.0.1': dependencies: @@ -6766,37 +6897,37 @@ snapshots: '@smithy/property-provider': 4.0.1 '@smithy/types': 4.1.0 '@smithy/url-parser': 4.0.1 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/eventstream-codec@4.0.1': dependencies: '@aws-crypto/crc32': 5.2.0 '@smithy/types': 4.1.0 '@smithy/util-hex-encoding': 4.0.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/eventstream-serde-browser@4.0.1': dependencies: '@smithy/eventstream-serde-universal': 4.0.1 '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/eventstream-serde-config-resolver@4.0.1': dependencies: '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/eventstream-serde-node@4.0.1': dependencies: '@smithy/eventstream-serde-universal': 4.0.1 '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/eventstream-serde-universal@4.0.1': dependencies: '@smithy/eventstream-codec': 4.0.1 '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/fetch-http-handler@5.0.1': dependencies: @@ -6804,33 +6935,33 @@ snapshots: '@smithy/querystring-builder': 4.0.1 '@smithy/types': 4.1.0 '@smithy/util-base64': 4.0.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/hash-node@4.0.1': dependencies: '@smithy/types': 4.1.0 '@smithy/util-buffer-from': 4.0.0 '@smithy/util-utf8': 4.0.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/invalid-dependency@4.0.1': dependencies: '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/is-array-buffer@2.2.0': dependencies: - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/is-array-buffer@4.0.0': dependencies: - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/middleware-content-length@4.0.1': dependencies: '@smithy/protocol-http': 5.0.1 '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/middleware-endpoint@4.0.2': dependencies: @@ -6841,7 +6972,7 @@ snapshots: '@smithy/types': 4.1.0 '@smithy/url-parser': 4.0.1 '@smithy/util-middleware': 4.0.1 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/middleware-retry@4.0.3': dependencies: @@ -6852,25 +6983,25 @@ snapshots: '@smithy/types': 4.1.0 '@smithy/util-middleware': 4.0.1 '@smithy/util-retry': 4.0.1 - tslib: 2.6.2 + tslib: 2.8.1 uuid: 9.0.1 '@smithy/middleware-serde@4.0.1': dependencies: '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/middleware-stack@4.0.1': dependencies: '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/node-config-provider@4.0.1': dependencies: '@smithy/property-provider': 4.0.1 '@smithy/shared-ini-file-loader': 4.0.1 '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/node-http-handler@4.0.2': dependencies: @@ -6878,28 +7009,28 @@ snapshots: '@smithy/protocol-http': 5.0.1 '@smithy/querystring-builder': 4.0.1 '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/property-provider@4.0.1': dependencies: '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/protocol-http@5.0.1': dependencies: '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/querystring-builder@4.0.1': dependencies: '@smithy/types': 4.1.0 '@smithy/util-uri-escape': 4.0.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/querystring-parser@4.0.1': dependencies: '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/service-error-classification@4.0.1': dependencies: @@ -6908,7 +7039,7 @@ snapshots: '@smithy/shared-ini-file-loader@4.0.1': dependencies: '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/signature-v4@5.0.1': dependencies: @@ -6919,7 +7050,7 @@ snapshots: '@smithy/util-middleware': 4.0.1 '@smithy/util-uri-escape': 4.0.0 '@smithy/util-utf8': 4.0.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/smithy-client@4.1.2': dependencies: @@ -6929,49 +7060,49 @@ snapshots: '@smithy/protocol-http': 5.0.1 '@smithy/types': 4.1.0 '@smithy/util-stream': 4.0.2 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/types@2.4.0': dependencies: - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/types@4.1.0': dependencies: - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/url-parser@4.0.1': dependencies: '@smithy/querystring-parser': 4.0.1 '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-base64@4.0.0': dependencies: '@smithy/util-buffer-from': 4.0.0 '@smithy/util-utf8': 4.0.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-body-length-browser@4.0.0': dependencies: - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-body-length-node@4.0.0': dependencies: - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-buffer-from@2.2.0': dependencies: '@smithy/is-array-buffer': 2.2.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-buffer-from@4.0.0': dependencies: '@smithy/is-array-buffer': 4.0.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-config-provider@4.0.0': dependencies: - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-defaults-mode-browser@4.0.3': dependencies: @@ -6979,7 +7110,7 @@ snapshots: '@smithy/smithy-client': 4.1.2 '@smithy/types': 4.1.0 bowser: 2.11.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-defaults-mode-node@4.0.3': dependencies: @@ -6989,28 +7120,28 @@ snapshots: '@smithy/property-provider': 4.0.1 '@smithy/smithy-client': 4.1.2 '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-endpoints@3.0.1': dependencies: '@smithy/node-config-provider': 4.0.1 '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-hex-encoding@4.0.0': dependencies: - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-middleware@4.0.1': dependencies: '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-retry@4.0.1': dependencies: '@smithy/service-error-classification': 4.0.1 '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-stream@4.0.2': dependencies: @@ -7021,27 +7152,27 @@ snapshots: '@smithy/util-buffer-from': 4.0.0 '@smithy/util-hex-encoding': 4.0.0 '@smithy/util-utf8': 4.0.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-uri-escape@4.0.0': dependencies: - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-utf8@2.3.0': dependencies: '@smithy/util-buffer-from': 2.2.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-utf8@4.0.0': dependencies: '@smithy/util-buffer-from': 4.0.0 - tslib: 2.6.2 + tslib: 2.8.1 '@smithy/util-waiter@4.0.2': dependencies: '@smithy/abort-controller': 4.0.1 '@smithy/types': 4.1.0 - tslib: 2.6.2 + tslib: 2.8.1 '@solidity-parser/parser@0.14.5': dependencies: @@ -7051,11 +7182,11 @@ snapshots: dependencies: antlr4ts: 0.5.0-alpha.4 - '@starboardventures/hardhat-verify@1.0.1(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))': + '@solidity-parser/parser@0.16.2': dependencies: - fs-extra: 11.2.0 - hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10) - node-fetch: 2.0.0 + antlr4ts: 0.5.0-alpha.4 + + '@solidity-parser/parser@0.19.0': {} '@swc/core-darwin-arm64@1.6.3': optional: true @@ -7090,7 +7221,7 @@ snapshots: '@swc/core@1.6.3': dependencies: '@swc/counter': 0.1.3 - '@swc/types': 0.1.8 + '@swc/types': 0.1.17 optionalDependencies: '@swc/core-darwin-arm64': 1.6.3 '@swc/core-darwin-x64': 1.6.3 @@ -7105,38 +7236,10 @@ snapshots: '@swc/counter@0.1.3': {} - '@swc/types@0.1.8': + '@swc/types@0.1.17': dependencies: '@swc/counter': 0.1.3 - '@tenderly/hardhat-tenderly@2.3.0(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(@swc/core@1.6.3)(@types/node@18.18.7)(bufferutil@4.0.8)(encoding@0.1.13)(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10)': - dependencies: - '@ethersproject/bignumber': 5.7.0 - '@nomicfoundation/hardhat-ignition': 0.15.5(@nomicfoundation/hardhat-verify@2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(bufferutil@4.0.8)(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10) - '@nomicfoundation/hardhat-verify': 2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)) - '@openzeppelin/hardhat-upgrades': 3.9.0(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(@nomicfoundation/hardhat-verify@2.0.9(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(encoding@0.1.13)(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)) - '@openzeppelin/upgrades-core': 1.35.1 - axios: 1.7.2 - ethers: 6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) - fs-extra: 10.1.0 - hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10) - hardhat-deploy: 0.11.45(bufferutil@4.0.8)(utf-8-validate@5.0.10) - tenderly: 0.9.1(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.4))(typescript@5.5.4) - ts-node: 10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.4) - tslog: 4.9.3 - typescript: 5.5.4 - transitivePeerDependencies: - - '@nomicfoundation/hardhat-ethers' - - '@swc/core' - - '@swc/wasm' - - '@types/node' - - aws-crt - - bufferutil - - debug - - encoding - - supports-color - - utf-8-validate - '@trivago/prettier-plugin-sort-imports@3.4.0(prettier@2.8.8)': dependencies: '@babel/core': 7.17.8 @@ -7159,31 +7262,31 @@ snapshots: '@tsconfig/node16@1.0.4': {} - '@typechain/ethers-v6@0.4.3(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.5.3))(typescript@5.5.3)': + '@typechain/ethers-v6@0.4.3(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.7.3))(typescript@5.7.3)': dependencies: - ethers: 6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) + ethers: 6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10) lodash: 4.17.21 - ts-essentials: 7.0.3(typescript@5.5.3) - typechain: 8.3.2(typescript@5.5.3) - typescript: 5.5.3 + ts-essentials: 7.0.3(typescript@5.7.3) + typechain: 8.3.2(typescript@5.7.3) + typescript: 5.7.3 - '@typechain/hardhat@9.1.0(@typechain/ethers-v6@0.4.3(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.5.3))(typescript@5.5.3))(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.5.3))': + '@typechain/hardhat@9.1.0(@typechain/ethers-v6@0.4.3(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.7.3))(typescript@5.7.3))(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.7.3))': dependencies: - '@typechain/ethers-v6': 0.4.3(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.5.3))(typescript@5.5.3) - ethers: 6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) + '@typechain/ethers-v6': 0.4.3(ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.7.3))(typescript@5.7.3) + ethers: 6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10) fs-extra: 9.1.0 - hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10) - typechain: 8.3.2(typescript@5.5.3) + hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10) + typechain: 8.3.2(typescript@5.7.3) '@types/bn.js@4.11.6': dependencies: - '@types/node': 18.18.7 + '@types/node': 18.19.71 '@types/bn.js@5.1.3': dependencies: - '@types/node': 18.18.7 + '@types/node': 18.19.71 - '@types/chai-as-promised@7.1.7': + '@types/chai-as-promised@7.1.8': dependencies: '@types/chai': 4.3.11 @@ -7191,20 +7294,22 @@ snapshots: '@types/concat-stream@1.6.1': dependencies: - '@types/node': 18.18.7 + '@types/node': 18.19.71 '@types/estree@1.0.3': {} '@types/estree@1.0.5': {} + '@types/estree@1.0.6': {} + '@types/form-data@0.0.33': dependencies: - '@types/node': 18.18.7 + '@types/node': 18.19.71 '@types/glob@7.2.0': dependencies: '@types/minimatch': 5.1.2 - '@types/node': 18.18.7 + '@types/node': 18.19.71 '@types/lru-cache@5.1.1': {} @@ -7216,111 +7321,113 @@ snapshots: '@types/node@10.17.60': {} - '@types/node@18.15.13': {} - - '@types/node@18.18.7': + '@types/node@18.19.71': dependencies: undici-types: 5.26.5 '@types/node@20.5.1': {} + '@types/node@22.7.5': + dependencies: + undici-types: 6.19.8 + '@types/node@8.10.66': {} '@types/normalize-package-data@2.4.3': {} '@types/pbkdf2@3.1.1': dependencies: - '@types/node': 18.18.7 + '@types/node': 18.19.71 '@types/prettier@2.7.3': {} - '@types/qs@6.9.9': {} + '@types/qs@6.9.18': {} '@types/resolve@1.20.2': {} '@types/secp256k1@4.0.5': dependencies: - '@types/node': 18.18.7 + '@types/node': 18.19.71 - '@typescript-eslint/eslint-plugin@7.12.0(@typescript-eslint/parser@7.12.0(eslint@8.52.0)(typescript@5.5.3))(eslint@8.52.0)(typescript@5.5.3)': + '@typescript-eslint/eslint-plugin@7.18.0(@typescript-eslint/parser@7.18.0(eslint@8.57.1)(typescript@5.7.3))(eslint@8.57.1)(typescript@5.7.3)': dependencies: '@eslint-community/regexpp': 4.10.0 - '@typescript-eslint/parser': 7.12.0(eslint@8.52.0)(typescript@5.5.3) - '@typescript-eslint/scope-manager': 7.12.0 - '@typescript-eslint/type-utils': 7.12.0(eslint@8.52.0)(typescript@5.5.3) - '@typescript-eslint/utils': 7.12.0(eslint@8.52.0)(typescript@5.5.3) - '@typescript-eslint/visitor-keys': 7.12.0 - eslint: 8.52.0 + '@typescript-eslint/parser': 7.18.0(eslint@8.57.1)(typescript@5.7.3) + '@typescript-eslint/scope-manager': 7.18.0 + '@typescript-eslint/type-utils': 7.18.0(eslint@8.57.1)(typescript@5.7.3) + '@typescript-eslint/utils': 7.18.0(eslint@8.57.1)(typescript@5.7.3) + '@typescript-eslint/visitor-keys': 7.18.0 + eslint: 8.57.1 graphemer: 1.4.0 ignore: 5.3.1 natural-compare: 1.4.0 - ts-api-utils: 1.3.0(typescript@5.5.3) + ts-api-utils: 1.3.0(typescript@5.7.3) optionalDependencies: - typescript: 5.5.3 + typescript: 5.7.3 transitivePeerDependencies: - supports-color - '@typescript-eslint/parser@7.12.0(eslint@8.52.0)(typescript@5.5.3)': + '@typescript-eslint/parser@7.18.0(eslint@8.57.1)(typescript@5.7.3)': dependencies: - '@typescript-eslint/scope-manager': 7.12.0 - '@typescript-eslint/types': 7.12.0 - '@typescript-eslint/typescript-estree': 7.12.0(typescript@5.5.3) - '@typescript-eslint/visitor-keys': 7.12.0 + '@typescript-eslint/scope-manager': 7.18.0 + '@typescript-eslint/types': 7.18.0 + '@typescript-eslint/typescript-estree': 7.18.0(typescript@5.7.3) + '@typescript-eslint/visitor-keys': 7.18.0 debug: 4.3.4(supports-color@8.1.1) - eslint: 8.52.0 + eslint: 8.57.1 optionalDependencies: - typescript: 5.5.3 + typescript: 5.7.3 transitivePeerDependencies: - supports-color - '@typescript-eslint/scope-manager@7.12.0': + '@typescript-eslint/scope-manager@7.18.0': dependencies: - '@typescript-eslint/types': 7.12.0 - '@typescript-eslint/visitor-keys': 7.12.0 + '@typescript-eslint/types': 7.18.0 + '@typescript-eslint/visitor-keys': 7.18.0 - '@typescript-eslint/type-utils@7.12.0(eslint@8.52.0)(typescript@5.5.3)': + '@typescript-eslint/type-utils@7.18.0(eslint@8.57.1)(typescript@5.7.3)': dependencies: - '@typescript-eslint/typescript-estree': 7.12.0(typescript@5.5.3) - '@typescript-eslint/utils': 7.12.0(eslint@8.52.0)(typescript@5.5.3) - debug: 4.3.4(supports-color@8.1.1) - eslint: 8.52.0 - ts-api-utils: 1.3.0(typescript@5.5.3) + '@typescript-eslint/typescript-estree': 7.18.0(typescript@5.7.3) + '@typescript-eslint/utils': 7.18.0(eslint@8.57.1)(typescript@5.7.3) + debug: 4.4.0(supports-color@8.1.1) + eslint: 8.57.1 + ts-api-utils: 1.3.0(typescript@5.7.3) optionalDependencies: - typescript: 5.5.3 + typescript: 5.7.3 transitivePeerDependencies: - supports-color - '@typescript-eslint/types@7.12.0': {} + '@typescript-eslint/types@7.18.0': {} - '@typescript-eslint/typescript-estree@7.12.0(typescript@5.5.3)': + '@typescript-eslint/typescript-estree@7.18.0(typescript@5.7.3)': dependencies: - '@typescript-eslint/types': 7.12.0 - '@typescript-eslint/visitor-keys': 7.12.0 + '@typescript-eslint/types': 7.18.0 + '@typescript-eslint/visitor-keys': 7.18.0 debug: 4.3.4(supports-color@8.1.1) globby: 11.1.0 is-glob: 4.0.3 - minimatch: 9.0.4 - semver: 7.6.2 - ts-api-utils: 1.3.0(typescript@5.5.3) + minimatch: 9.0.5 + semver: 7.6.3 + ts-api-utils: 1.4.3(typescript@5.7.3) optionalDependencies: - typescript: 5.5.3 + typescript: 5.7.3 transitivePeerDependencies: - supports-color - '@typescript-eslint/utils@7.12.0(eslint@8.52.0)(typescript@5.5.3)': + '@typescript-eslint/utils@7.18.0(eslint@8.57.1)(typescript@5.7.3)': dependencies: - '@eslint-community/eslint-utils': 4.4.0(eslint@8.52.0) - '@typescript-eslint/scope-manager': 7.12.0 - '@typescript-eslint/types': 7.12.0 - '@typescript-eslint/typescript-estree': 7.12.0(typescript@5.5.3) - eslint: 8.52.0 + '@eslint-community/eslint-utils': 4.4.1(eslint@8.57.1) + '@typescript-eslint/scope-manager': 7.18.0 + '@typescript-eslint/types': 7.18.0 + '@typescript-eslint/typescript-estree': 7.18.0(typescript@5.7.3) + eslint: 8.57.1 transitivePeerDependencies: - supports-color - typescript - '@typescript-eslint/visitor-keys@7.12.0': + '@typescript-eslint/visitor-keys@7.18.0': dependencies: - '@typescript-eslint/types': 7.12.0 + '@typescript-eslint/types': 7.18.0 eslint-visitor-keys: 3.4.3 '@ungap/structured-clone@1.2.0': {} @@ -7372,14 +7479,14 @@ snapshots: abbrev@1.0.9: {} - abitype@0.9.8(typescript@5.5.3)(zod@3.23.8): + abitype@0.9.8(typescript@5.7.3)(zod@3.23.8): optionalDependencies: - typescript: 5.5.3 + typescript: 5.7.3 zod: 3.23.8 - abitype@1.0.5(typescript@5.5.3)(zod@3.23.8): + abitype@1.0.7(typescript@5.7.3)(zod@3.23.8): optionalDependencies: - typescript: 5.5.3 + typescript: 5.7.3 zod: 3.23.8 acorn-jsx@5.3.2(acorn@8.11.3): @@ -7423,6 +7530,13 @@ snapshots: require-from-string: 2.0.2 uri-js: 4.4.1 + ajv@8.17.1: + dependencies: + fast-deep-equal: 3.1.3 + fast-uri: 3.0.5 + json-schema-traverse: 1.0.0 + require-from-string: 2.0.2 + amazon-cognito-identity-js@6.3.6(encoding@0.1.13): dependencies: '@aws-crypto/sha256-js': 1.2.2 @@ -7543,27 +7657,6 @@ snapshots: dependencies: possible-typed-array-names: 1.0.0 - axios@0.21.4(debug@4.3.4): - dependencies: - follow-redirects: 1.15.6(debug@4.3.4) - transitivePeerDependencies: - - debug - - axios@0.27.2: - dependencies: - follow-redirects: 1.15.6(debug@4.3.4) - form-data: 4.0.0 - transitivePeerDependencies: - - debug - - axios@1.7.2: - dependencies: - follow-redirects: 1.15.6(debug@4.3.4) - form-data: 4.0.0 - proxy-from-env: 1.1.0 - transitivePeerDependencies: - - debug - axios@1.7.9(debug@4.3.4): dependencies: follow-redirects: 1.15.6(debug@4.3.4) @@ -7624,6 +7717,10 @@ snapshots: dependencies: fill-range: 7.0.1 + braces@3.0.3: + dependencies: + fill-range: 7.1.1 + brorand@1.1.0: {} browser-stdout@1.3.1: {} @@ -7671,13 +7768,11 @@ snapshots: bufferutil@4.0.8: dependencies: - node-gyp-build: 4.6.1 + node-gyp-build: 4.8.4 optional: true bufio@1.2.1: {} - builtin-modules@3.3.0: {} - builtins@2.0.1: dependencies: semver: 6.3.1 @@ -7686,6 +7781,11 @@ snapshots: cachedir@2.3.0: {} + call-bind-apply-helpers@1.0.1: + dependencies: + es-errors: 1.3.0 + function-bind: 1.1.2 + call-bind@1.0.7: dependencies: es-define-property: 1.0.0 @@ -7694,6 +7794,11 @@ snapshots: get-intrinsic: 1.2.4 set-function-length: 1.2.2 + call-bound@1.0.3: + dependencies: + call-bind-apply-helpers: 1.0.1 + get-intrinsic: 1.2.7 + callsites@3.1.0: {} camelcase-keys@6.2.2: @@ -7718,7 +7823,11 @@ snapshots: dependencies: nofilter: 3.1.0 - chai-as-promised@7.1.1(chai@4.5.0): + cbor@9.0.2: + dependencies: + nofilter: 3.1.0 + + chai-as-promised@7.1.2(chai@4.5.0): dependencies: chai: 4.5.0 check-error: 1.0.3 @@ -7769,7 +7878,7 @@ snapshots: chokidar@3.6.0: dependencies: anymatch: 3.1.3 - braces: 3.0.2 + braces: 3.0.3 glob-parent: 5.1.2 is-binary-path: 2.1.0 is-glob: 4.0.3 @@ -7810,12 +7919,6 @@ snapshots: optionalDependencies: colors: 1.4.0 - cli-table3@0.6.3: - dependencies: - string-width: 4.2.3 - optionalDependencies: - '@colors/colors': 1.5.0 - cli-truncate@3.1.0: dependencies: slice-ansi: 5.0.0 @@ -7879,12 +7982,10 @@ snapshots: commander@8.3.0: {} - commander@9.5.0: {} - - commitizen@4.3.0(typescript@5.5.3): + commitizen@4.3.1(typescript@5.7.3): dependencies: cachedir: 2.3.0 - cz-conventional-changelog: 3.3.0(typescript@5.5.3) + cz-conventional-changelog: 3.3.0(typescript@5.7.3) dedent: 0.7.0 detect-indent: 6.1.0 find-node-modules: 2.1.3 @@ -7941,29 +8042,29 @@ snapshots: core-util-is@1.0.3: {} - cosmiconfig-typescript-loader@4.4.0(@types/node@20.5.1)(cosmiconfig@8.3.6(typescript@5.5.3))(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@20.5.1)(typescript@5.5.3))(typescript@5.5.3): + cosmiconfig-typescript-loader@4.4.0(@types/node@20.5.1)(cosmiconfig@8.3.6(typescript@5.7.3))(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@20.5.1)(typescript@5.7.3))(typescript@5.7.3): dependencies: '@types/node': 20.5.1 - cosmiconfig: 8.3.6(typescript@5.5.3) - ts-node: 10.9.1(@swc/core@1.6.3)(@types/node@20.5.1)(typescript@5.5.3) - typescript: 5.5.3 + cosmiconfig: 8.3.6(typescript@5.7.3) + ts-node: 10.9.2(@swc/core@1.6.3)(@types/node@20.5.1)(typescript@5.7.3) + typescript: 5.7.3 - cosmiconfig-typescript-loader@5.0.0(@types/node@18.18.7)(cosmiconfig@8.3.6(typescript@5.5.3))(typescript@5.5.3): + cosmiconfig-typescript-loader@5.0.0(@types/node@18.19.71)(cosmiconfig@8.3.6(typescript@5.7.3))(typescript@5.7.3): dependencies: - '@types/node': 18.18.7 - cosmiconfig: 8.3.6(typescript@5.5.3) + '@types/node': 18.19.71 + cosmiconfig: 8.3.6(typescript@5.7.3) jiti: 1.20.0 - typescript: 5.5.3 + typescript: 5.7.3 optional: true - cosmiconfig@8.3.6(typescript@5.5.3): + cosmiconfig@8.3.6(typescript@5.7.3): dependencies: import-fresh: 3.3.0 js-yaml: 4.1.0 parse-json: 5.2.0 path-type: 4.0.0 optionalDependencies: - typescript: 5.5.3 + typescript: 5.7.3 create-hash@1.2.0: dependencies: @@ -7996,16 +8097,16 @@ snapshots: crypt@0.0.2: {} - cz-conventional-changelog@3.3.0(typescript@5.5.3): + cz-conventional-changelog@3.3.0(typescript@5.7.3): dependencies: chalk: 2.4.2 - commitizen: 4.3.0(typescript@5.5.3) + commitizen: 4.3.1(typescript@5.7.3) conventional-commit-types: 3.0.0 lodash.map: 4.6.0 longest: 2.0.1 word-wrap: 1.2.5 optionalDependencies: - '@commitlint/load': 18.2.0(typescript@5.5.3) + '@commitlint/load': 18.2.0(typescript@5.7.3) transitivePeerDependencies: - typescript @@ -8037,6 +8138,12 @@ snapshots: optionalDependencies: supports-color: 8.1.1 + debug@4.4.0(supports-color@8.1.1): + dependencies: + ms: 2.1.3 + optionalDependencies: + supports-color: 8.1.1 + decamelize-keys@1.1.1: dependencies: decamelize: 1.2.0 @@ -8052,6 +8159,10 @@ snapshots: dependencies: type-detect: 4.1.0 + deep-eql@4.1.4: + dependencies: + type-detect: 4.1.0 + deep-extend@0.6.0: {} deep-is@0.1.4: {} @@ -8068,8 +8179,6 @@ snapshots: es-errors: 1.3.0 gopd: 1.0.1 - define-lazy-prop@2.0.0: {} - define-properties@1.2.1: dependencies: define-data-property: 1.1.4 @@ -8091,10 +8200,10 @@ snapshots: detect-indent@6.1.0: {} - detect-port@1.5.1: + detect-port@1.6.1: dependencies: address: 1.2.2 - debug: 4.3.4(supports-color@8.1.1) + debug: 4.4.0(supports-color@8.1.1) transitivePeerDependencies: - supports-color @@ -8102,6 +8211,8 @@ snapshots: diff@5.0.0: {} + diff@5.2.0: {} + difflib@0.2.4: dependencies: heap: 0.2.7 @@ -8118,7 +8229,13 @@ snapshots: dependencies: is-obj: 2.0.0 - dotenv@16.3.1: {} + dotenv@16.4.7: {} + + dunder-proto@1.0.1: + dependencies: + call-bind-apply-helpers: 1.0.1 + es-errors: 1.3.0 + gopd: 1.2.0 eastasianwidth@0.2.0: {} @@ -8209,6 +8326,8 @@ snapshots: dependencies: get-intrinsic: 1.2.4 + es-define-property@1.0.1: {} + es-errors@1.3.0: {} es-module-lexer@1.3.1: {} @@ -8217,6 +8336,10 @@ snapshots: dependencies: es-errors: 1.3.0 + es-object-atoms@1.1.1: + dependencies: + es-errors: 1.3.0 + es-set-tostringtag@2.0.3: dependencies: get-intrinsic: 1.2.4 @@ -8274,9 +8397,9 @@ snapshots: optionalDependencies: source-map: 0.2.0 - eslint-config-prettier@8.10.0(eslint@8.52.0): + eslint-config-prettier@8.10.0(eslint@8.57.1): dependencies: - eslint: 8.52.0 + eslint: 8.57.1 eslint-scope@7.2.2: dependencies: @@ -8285,13 +8408,13 @@ snapshots: eslint-visitor-keys@3.4.3: {} - eslint@8.52.0: + eslint@8.57.1: dependencies: - '@eslint-community/eslint-utils': 4.4.0(eslint@8.52.0) + '@eslint-community/eslint-utils': 4.4.0(eslint@8.57.1) '@eslint-community/regexpp': 4.10.0 - '@eslint/eslintrc': 2.1.2 - '@eslint/js': 8.52.0 - '@humanwhocodes/config-array': 0.11.13 + '@eslint/eslintrc': 2.1.4 + '@eslint/js': 8.57.1 + '@humanwhocodes/config-array': 0.13.0 '@humanwhocodes/module-importer': 1.0.1 '@nodelib/fs.walk': 1.2.8 '@ungap/structured-clone': 1.2.0 @@ -8367,7 +8490,7 @@ snapshots: fs-readdir-recursive: 1.1.0 lodash: 4.17.21 markdown-table: 1.1.3 - mocha: 10.2.0 + mocha: 10.8.2 req-cwd: 2.0.0 sha1: 1.1.1 sync-request: 6.1.0 @@ -8376,9 +8499,9 @@ snapshots: - debug - utf-8-validate - ethereum-bloom-filters@1.0.10: + ethereum-bloom-filters@1.2.0: dependencies: - js-sha3: 0.8.0 + '@noble/hashes': 1.7.1 ethereum-cryptography@0.1.3: dependencies: @@ -8405,12 +8528,12 @@ snapshots: '@scure/bip32': 1.1.5 '@scure/bip39': 1.1.1 - ethereum-cryptography@2.1.2: + ethereum-cryptography@2.2.1: dependencies: - '@noble/curves': 1.1.0 - '@noble/hashes': 1.3.1 - '@scure/bip32': 1.3.1 - '@scure/bip39': 1.2.1 + '@noble/curves': 1.4.2 + '@noble/hashes': 1.4.0 + '@scure/bip32': 1.4.0 + '@scure/bip39': 1.3.0 ethereumjs-abi@0.6.8: dependencies: @@ -8471,32 +8594,19 @@ snapshots: - bufferutil - utf-8-validate - ethers@6.13.1(bufferutil@4.0.8)(utf-8-validate@5.0.10): + ethers@6.13.5(bufferutil@4.0.8)(utf-8-validate@5.0.10): dependencies: '@adraffy/ens-normalize': 1.10.1 '@noble/curves': 1.2.0 '@noble/hashes': 1.3.2 - '@types/node': 18.15.13 + '@types/node': 22.7.5 aes-js: 4.0.0-beta.5 - tslib: 2.4.0 + tslib: 2.7.0 ws: 8.17.1(bufferutil@4.0.8)(utf-8-validate@5.0.10) transitivePeerDependencies: - bufferutil - utf-8-validate - ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10): - dependencies: - '@adraffy/ens-normalize': 1.10.0 - '@noble/curves': 1.2.0 - '@noble/hashes': 1.3.2 - '@types/node': 18.15.13 - aes-js: 4.0.0-beta.5 - tslib: 2.4.0 - ws: 8.5.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) - transitivePeerDependencies: - - bufferutil - - utf-8-validate - ethjs-unit@0.1.6: dependencies: bn.js: 4.11.6 @@ -8554,18 +8664,20 @@ snapshots: fast-diff@1.3.0: {} - fast-glob@3.3.2: + fast-glob@3.3.3: dependencies: '@nodelib/fs.stat': 2.0.5 '@nodelib/fs.walk': 1.2.8 glob-parent: 5.1.2 merge2: 1.4.1 - micromatch: 4.0.5 + micromatch: 4.0.8 fast-json-stable-stringify@2.1.0: {} fast-levenshtein@2.0.6: {} + fast-uri@3.0.5: {} + fast-xml-parser@4.4.1: dependencies: strnum: 1.0.5 @@ -8590,6 +8702,10 @@ snapshots: dependencies: to-regex-range: 5.0.1 + fill-range@7.1.1: + dependencies: + to-regex-range: 5.0.1 + find-node-modules@2.1.3: dependencies: findup-sync: 4.0.0 @@ -8645,11 +8761,12 @@ snapshots: cross-spawn: 7.0.3 signal-exit: 4.1.0 - form-data@2.5.1: + form-data@2.5.2: dependencies: asynckit: 0.4.0 combined-stream: 1.0.8 mime-types: 2.1.35 + safe-buffer: 5.2.1 form-data@4.0.0: dependencies: @@ -8663,7 +8780,7 @@ snapshots: dependencies: graceful-fs: 4.2.11 jsonfile: 6.1.0 - universalify: 2.0.0 + universalify: 2.0.1 fs-extra@11.2.0: dependencies: @@ -8722,8 +8839,26 @@ snapshots: has-symbols: 1.0.3 hasown: 2.0.2 + get-intrinsic@1.2.7: + dependencies: + call-bind-apply-helpers: 1.0.1 + es-define-property: 1.0.1 + es-errors: 1.3.0 + es-object-atoms: 1.1.1 + function-bind: 1.1.2 + get-proto: 1.0.1 + gopd: 1.2.0 + has-symbols: 1.1.0 + hasown: 2.0.2 + math-intrinsics: 1.1.0 + get-port@3.2.0: {} + get-proto@1.0.1: + dependencies: + dunder-proto: 1.0.1 + es-object-atoms: 1.1.1 + get-stream@6.0.1: {} get-symbol-description@1.0.2: @@ -8855,9 +8990,9 @@ snapshots: '@types/glob': 7.2.0 array-union: 2.1.0 dir-glob: 3.0.1 - fast-glob: 3.3.2 + fast-glob: 3.3.3 glob: 7.2.3 - ignore: 5.3.1 + ignore: 5.3.2 merge2: 1.4.1 slash: 3.0.0 @@ -8865,8 +9000,8 @@ snapshots: dependencies: array-union: 2.1.0 dir-glob: 3.0.1 - fast-glob: 3.3.2 - ignore: 5.3.1 + fast-glob: 3.3.3 + ignore: 5.3.2 merge2: 1.4.1 slash: 3.0.0 @@ -8874,6 +9009,8 @@ snapshots: dependencies: get-intrinsic: 1.2.4 + gopd@1.2.0: {} + graceful-fs@4.2.11: {} graphemer@1.4.0: {} @@ -8885,52 +9022,21 @@ snapshots: source-map: 0.6.1 wordwrap: 1.0.0 optionalDependencies: - uglify-js: 3.17.4 + uglify-js: 3.19.3 hard-rejection@2.1.0: {} - hardhat-abi-exporter@2.10.1(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)): + hardhat-abi-exporter@2.10.1(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)): dependencies: '@ethersproject/abi': 5.7.0 delete-empty: 3.0.0 - hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10) + hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10) - hardhat-deploy@0.11.45(bufferutil@4.0.8)(utf-8-validate@5.0.10): - dependencies: - '@ethersproject/abi': 5.7.0 - '@ethersproject/abstract-signer': 5.7.0 - '@ethersproject/address': 5.7.0 - '@ethersproject/bignumber': 5.7.0 - '@ethersproject/bytes': 5.7.0 - '@ethersproject/constants': 5.7.0 - '@ethersproject/contracts': 5.7.0 - '@ethersproject/providers': 5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) - '@ethersproject/solidity': 5.7.0 - '@ethersproject/transactions': 5.7.0 - '@ethersproject/wallet': 5.7.0 - '@types/qs': 6.9.9 - axios: 0.21.4(debug@4.3.4) - chalk: 4.1.2 - chokidar: 3.6.0 - debug: 4.3.4(supports-color@8.1.1) - enquirer: 2.4.1 - ethers: 5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) - form-data: 4.0.0 - fs-extra: 10.1.0 - match-all: 1.2.6 - murmur-128: 0.2.1 - qs: 6.11.2 - zksync-web3: 0.14.4(ethers@5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10)) - transitivePeerDependencies: - - bufferutil - - supports-color - - utf-8-validate - - hardhat-gas-reporter@1.0.9(bufferutil@4.0.8)(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10): + hardhat-gas-reporter@1.0.9(bufferutil@4.0.8)(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10))(utf-8-validate@5.0.10): dependencies: array-uniq: 1.0.3 eth-gas-reporter: 0.2.27(bufferutil@4.0.8)(utf-8-validate@5.0.10) - hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10) + hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10) sha1: 1.1.1 transitivePeerDependencies: - '@codechecks/client' @@ -8938,12 +9044,12 @@ snapshots: - debug - utf-8-validate - hardhat-preprocessor@0.1.5(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)): + hardhat-preprocessor@0.1.5(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)): dependencies: - hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10) + hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10) murmur-128: 0.2.1 - hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10): + hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10): dependencies: '@ethersproject/abi': 5.7.0 '@metamask/eth-sig-util': 4.0.1 @@ -8990,8 +9096,8 @@ snapshots: uuid: 8.3.2 ws: 7.5.9(bufferutil@4.0.8)(utf-8-validate@5.0.10) optionalDependencies: - ts-node: 10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3) - typescript: 5.5.3 + ts-node: 10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3) + typescript: 5.7.3 transitivePeerDependencies: - bufferutil - c-kzg @@ -9014,6 +9120,8 @@ snapshots: has-symbols@1.0.3: {} + has-symbols@1.1.0: {} + has-tostringtag@1.0.2: dependencies: has-symbols: 1.0.3 @@ -9098,6 +9206,8 @@ snapshots: ignore@5.3.1: {} + ignore@5.3.2: {} + immer@10.0.2: {} immutable@4.3.4: {} @@ -9172,10 +9282,6 @@ snapshots: call-bind: 1.0.7 has-tostringtag: 1.0.2 - is-builtin-module@3.2.1: - dependencies: - builtin-modules: 3.3.0 - is-callable@1.2.7: {} is-core-module@2.13.1: @@ -9190,8 +9296,6 @@ snapshots: dependencies: has-tostringtag: 1.0.2 - is-docker@2.2.1: {} - is-extglob@2.1.1: {} is-fullwidth-code-point@2.0.0: {} @@ -9269,10 +9373,6 @@ snapshots: is-windows@1.0.2: {} - is-wsl@2.2.0: - dependencies: - is-docker: 2.2.1 - isarray@1.0.0: {} isarray@2.0.5: {} @@ -9286,9 +9386,9 @@ snapshots: transitivePeerDependencies: - encoding - isows@1.0.4(ws@8.17.1(bufferutil@4.0.8)(utf-8-validate@5.0.10)): + isows@1.0.6(ws@8.18.0(bufferutil@4.0.8)(utf-8-validate@5.0.10)): dependencies: - ws: 8.17.1(bufferutil@4.0.8)(utf-8-validate@5.0.10) + ws: 8.18.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) jackspeak@2.3.6: dependencies: @@ -9348,7 +9448,7 @@ snapshots: jsonparse@1.3.1: {} - jsonschema@1.4.1: {} + jsonschema@1.5.0: {} keccak@3.0.4: dependencies: @@ -9507,7 +9607,7 @@ snapshots: markdown-table@1.1.3: {} - match-all@1.2.6: {} + math-intrinsics@1.1.0: {} md5.js@1.3.5: dependencies: @@ -9544,6 +9644,11 @@ snapshots: braces: 3.0.2 picomatch: 2.3.1 + micromatch@4.0.8: + dependencies: + braces: 3.0.3 + picomatch: 2.3.1 + mime-db@1.52.0: {} mime-types@2.1.35: @@ -9626,6 +9731,29 @@ snapshots: yargs-parser: 20.2.4 yargs-unparser: 2.0.0 + mocha@10.8.2: + dependencies: + ansi-colors: 4.1.3 + browser-stdout: 1.3.1 + chokidar: 3.6.0 + debug: 4.4.0(supports-color@8.1.1) + diff: 5.2.0 + escape-string-regexp: 4.0.0 + find-up: 5.0.0 + glob: 8.1.0 + he: 1.2.0 + js-yaml: 4.1.0 + log-symbols: 4.1.0 + minimatch: 5.1.6 + ms: 2.1.3 + serialize-javascript: 6.0.2 + strip-json-comments: 3.1.1 + supports-color: 8.1.1 + workerpool: 6.5.1 + yargs: 16.2.0 + yargs-parser: 20.2.9 + yargs-unparser: 2.0.0 + ms@2.1.2: {} ms@2.1.3: {} @@ -9660,8 +9788,6 @@ snapshots: dependencies: lodash: 4.17.21 - node-fetch@2.0.0: {} - node-fetch@2.7.0(encoding@0.1.13): dependencies: whatwg-url: 5.0.0 @@ -9670,6 +9796,9 @@ snapshots: node-gyp-build@4.6.1: {} + node-gyp-build@4.8.4: + optional: true + node-releases@2.0.13: {} nofilter@3.1.0: {} @@ -9689,7 +9818,7 @@ snapshots: dependencies: hosted-git-info: 4.1.0 is-core-module: 2.13.1 - semver: 7.6.2 + semver: 7.6.3 validate-npm-package-license: 3.0.4 normalize-path@3.0.0: {} @@ -9711,6 +9840,8 @@ snapshots: object-inspect@1.13.1: {} + object-inspect@1.13.3: {} + object-keys@1.1.1: {} object.assign@4.1.5: @@ -9734,12 +9865,6 @@ snapshots: dependencies: mimic-fn: 4.0.0 - open@8.4.2: - dependencies: - define-lazy-prop: 2.0.0 - is-docker: 2.2.1 - is-wsl: 2.2.0 - optionator@0.8.3: dependencies: deep-is: 0.1.4 @@ -9774,6 +9899,20 @@ snapshots: os-tmpdir@1.0.2: {} + ox@0.6.5(typescript@5.7.3)(zod@3.23.8): + dependencies: + '@adraffy/ens-normalize': 1.11.0 + '@noble/curves': 1.7.0 + '@noble/hashes': 1.6.1 + '@scure/bip32': 1.6.0 + '@scure/bip39': 1.5.0 + abitype: 1.0.7(typescript@5.7.3)(zod@3.23.8) + eventemitter3: 5.0.1 + optionalDependencies: + typescript: 5.7.3 + transitivePeerDependencies: + - zod + p-limit@2.3.0: dependencies: p-try: 2.2.0 @@ -9881,12 +10020,11 @@ snapshots: dependencies: fast-diff: 1.3.0 - prettier-plugin-solidity@1.1.3(prettier@2.8.8): + prettier-plugin-solidity@1.4.2(prettier@2.8.8): dependencies: - '@solidity-parser/parser': 0.16.1 + '@solidity-parser/parser': 0.19.0 prettier: 2.8.8 - semver: 7.6.2 - solidity-comments-extractor: 0.0.7 + semver: 7.6.3 prettier@2.8.8: {} @@ -9911,9 +10049,9 @@ snapshots: punycode@2.3.0: {} - qs@6.11.2: + qs@6.14.0: dependencies: - side-channel: 1.0.4 + side-channel: 1.1.0 queue-microtask@1.2.3: {} @@ -10060,7 +10198,7 @@ snapshots: dependencies: glob: 7.2.3 - rimraf@5.0.5: + rimraf@5.0.10: dependencies: glob: 10.3.10 @@ -10073,30 +10211,30 @@ snapshots: dependencies: bn.js: 5.2.1 - rollup-plugin-auto-external@2.0.0(rollup@4.6.1): + rollup-plugin-auto-external@2.0.0(rollup@4.31.0): dependencies: builtins: 2.0.1 read-pkg: 3.0.0 - rollup: 4.6.1 + rollup: 4.31.0 safe-resolve: 1.0.0 semver: 5.7.2 - rollup-plugin-dts@6.1.1(rollup@4.6.1)(typescript@5.5.3): + rollup-plugin-dts@6.1.1(rollup@4.31.0)(typescript@5.7.3): dependencies: magic-string: 0.30.10 - rollup: 4.6.1 - typescript: 5.5.3 + rollup: 4.31.0 + typescript: 5.7.3 optionalDependencies: '@babel/code-frame': 7.24.7 - rollup-plugin-esbuild@6.1.0(esbuild@0.21.5)(rollup@4.6.1): + rollup-plugin-esbuild@6.1.1(esbuild@0.21.5)(rollup@4.31.0): dependencies: - '@rollup/pluginutils': 5.0.5(rollup@4.6.1) + '@rollup/pluginutils': 5.0.5(rollup@4.31.0) debug: 4.3.4(supports-color@8.1.1) es-module-lexer: 1.3.1 esbuild: 0.21.5 get-tsconfig: 4.7.2 - rollup: 4.6.1 + rollup: 4.31.0 transitivePeerDependencies: - supports-color @@ -10110,38 +10248,47 @@ snapshots: dependencies: rollup-plugin-inject: 3.0.2 - rollup-plugin-swc3@0.11.2(@swc/core@1.6.3)(rollup@4.6.1): + rollup-plugin-swc3@0.11.2(@swc/core@1.6.3)(rollup@4.31.0): dependencies: '@fastify/deepmerge': 1.3.0 - '@rollup/pluginutils': 5.1.0(rollup@4.6.1) + '@rollup/pluginutils': 5.1.0(rollup@4.31.0) '@swc/core': 1.6.3 get-tsconfig: 4.7.5 - rollup: 4.6.1 - rollup-preserve-directives: 1.1.1(rollup@4.6.1) + rollup: 4.31.0 + rollup-preserve-directives: 1.1.1(rollup@4.31.0) rollup-pluginutils@2.8.2: dependencies: estree-walker: 0.6.1 - rollup-preserve-directives@1.1.1(rollup@4.6.1): + rollup-preserve-directives@1.1.1(rollup@4.31.0): dependencies: magic-string: 0.30.10 - rollup: 4.6.1 + rollup: 4.31.0 - rollup@4.6.1: + rollup@4.31.0: + dependencies: + '@types/estree': 1.0.6 optionalDependencies: - '@rollup/rollup-android-arm-eabi': 4.6.1 - '@rollup/rollup-android-arm64': 4.6.1 - '@rollup/rollup-darwin-arm64': 4.6.1 - '@rollup/rollup-darwin-x64': 4.6.1 - '@rollup/rollup-linux-arm-gnueabihf': 4.6.1 - '@rollup/rollup-linux-arm64-gnu': 4.6.1 - '@rollup/rollup-linux-arm64-musl': 4.6.1 - '@rollup/rollup-linux-x64-gnu': 4.6.1 - '@rollup/rollup-linux-x64-musl': 4.6.1 - '@rollup/rollup-win32-arm64-msvc': 4.6.1 - '@rollup/rollup-win32-ia32-msvc': 4.6.1 - '@rollup/rollup-win32-x64-msvc': 4.6.1 + '@rollup/rollup-android-arm-eabi': 4.31.0 + '@rollup/rollup-android-arm64': 4.31.0 + '@rollup/rollup-darwin-arm64': 4.31.0 + '@rollup/rollup-darwin-x64': 4.31.0 + '@rollup/rollup-freebsd-arm64': 4.31.0 + '@rollup/rollup-freebsd-x64': 4.31.0 + '@rollup/rollup-linux-arm-gnueabihf': 4.31.0 + '@rollup/rollup-linux-arm-musleabihf': 4.31.0 + '@rollup/rollup-linux-arm64-gnu': 4.31.0 + '@rollup/rollup-linux-arm64-musl': 4.31.0 + '@rollup/rollup-linux-loongarch64-gnu': 4.31.0 + '@rollup/rollup-linux-powerpc64le-gnu': 4.31.0 + '@rollup/rollup-linux-riscv64-gnu': 4.31.0 + '@rollup/rollup-linux-s390x-gnu': 4.31.0 + '@rollup/rollup-linux-x64-gnu': 4.31.0 + '@rollup/rollup-linux-x64-musl': 4.31.0 + '@rollup/rollup-win32-arm64-msvc': 4.31.0 + '@rollup/rollup-win32-ia32-msvc': 4.31.0 + '@rollup/rollup-win32-x64-msvc': 4.31.0 fsevents: 2.3.3 run-async@2.4.1: {} @@ -10152,7 +10299,7 @@ snapshots: rxjs@7.8.1: dependencies: - tslib: 2.6.2 + tslib: 2.8.1 safe-array-concat@1.1.2: dependencies: @@ -10210,10 +10357,16 @@ snapshots: semver@7.6.2: {} + semver@7.6.3: {} + serialize-javascript@6.0.0: dependencies: randombytes: 2.1.0 + serialize-javascript@6.0.2: + dependencies: + randombytes: 2.1.0 + set-function-length@1.2.2: dependencies: define-data-property: 1.1.4 @@ -10261,12 +10414,40 @@ snapshots: minimist: 1.2.8 shelljs: 0.8.5 + side-channel-list@1.0.0: + dependencies: + es-errors: 1.3.0 + object-inspect: 1.13.3 + + side-channel-map@1.0.1: + dependencies: + call-bound: 1.0.3 + es-errors: 1.3.0 + get-intrinsic: 1.2.7 + object-inspect: 1.13.3 + + side-channel-weakmap@1.0.2: + dependencies: + call-bound: 1.0.3 + es-errors: 1.3.0 + get-intrinsic: 1.2.7 + object-inspect: 1.13.3 + side-channel-map: 1.0.1 + side-channel@1.0.4: dependencies: call-bind: 1.0.7 get-intrinsic: 1.2.4 object-inspect: 1.13.1 + side-channel@1.1.0: + dependencies: + es-errors: 1.3.0 + object-inspect: 1.13.3 + side-channel-list: 1.0.0 + side-channel-map: 1.0.1 + side-channel-weakmap: 1.0.2 + signal-exit@3.0.7: {} signal-exit@4.1.0: {} @@ -10298,13 +10479,13 @@ snapshots: transitivePeerDependencies: - debug - solhint-plugin-prettier@0.0.5(prettier-plugin-solidity@1.1.3(prettier@2.8.8))(prettier@2.8.8): + solhint-plugin-prettier@0.0.5(prettier-plugin-solidity@1.4.2(prettier@2.8.8))(prettier@2.8.8): dependencies: prettier: 2.8.8 prettier-linter-helpers: 1.0.0 - prettier-plugin-solidity: 1.1.3(prettier@2.8.8) + prettier-plugin-solidity: 1.4.2(prettier@2.8.8) - solhint@3.6.2(typescript@5.5.3): + solhint@3.6.2(typescript@5.7.3): dependencies: '@solidity-parser/parser': 0.16.1 ajv: 6.12.6 @@ -10312,7 +10493,7 @@ snapshots: ast-parents: 0.0.1 chalk: 4.1.2 commander: 10.0.1 - cosmiconfig: 8.3.6(typescript@5.5.3) + cosmiconfig: 8.3.6(typescript@5.7.3) fast-diff: 1.3.0 glob: 8.1.0 ignore: 5.3.1 @@ -10332,35 +10513,33 @@ snapshots: dependencies: array.prototype.findlast: 1.2.3 - solidity-comments-extractor@0.0.7: {} - - solidity-coverage@0.8.5(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)): + solidity-coverage@0.8.5(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10)): dependencies: '@ethersproject/abi': 5.7.0 - '@solidity-parser/parser': 0.16.1 + '@solidity-parser/parser': 0.16.2 chalk: 2.4.2 death: 1.1.0 - detect-port: 1.5.1 + detect-port: 1.6.1 difflib: 0.2.4 fs-extra: 8.1.0 ghost-testrpc: 0.0.2 global-modules: 2.0.0 globby: 10.0.2 - hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10) - jsonschema: 1.4.1 + hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3))(typescript@5.7.3)(utf-8-validate@5.0.10) + jsonschema: 1.5.0 lodash: 4.17.21 mocha: 10.2.0 node-emoji: 1.11.0 pify: 4.0.1 recursive-readdir: 2.2.3 sc-istanbul: 0.4.6 - semver: 7.6.2 + semver: 7.6.3 shelljs: 0.8.5 - web3-utils: 1.10.3 + web3-utils: 1.10.4 transitivePeerDependencies: - supports-color - solmate@6.2.0: {} + solmate@6.8.0: {} source-map-js@1.0.2: {} @@ -10531,20 +10710,13 @@ snapshots: string-width: 4.2.3 strip-ansi: 6.0.1 - tenderly@0.9.1(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.4))(typescript@5.5.4): + table@6.9.0: dependencies: - axios: 0.27.2 - cli-table3: 0.6.3 - commander: 9.5.0 - js-yaml: 4.1.0 - open: 8.4.2 - prompts: 2.4.2 - tslog: 4.9.3 - optionalDependencies: - ts-node: 10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.4) - typescript: 5.5.4 - transitivePeerDependencies: - - debug + ajv: 8.17.1 + lodash.truncate: 4.4.2 + slice-ansi: 4.0.0 + string-width: 4.2.3 + strip-ansi: 6.0.1 text-extensions@1.9.0: {} @@ -10555,14 +10727,14 @@ snapshots: '@types/concat-stream': 1.6.1 '@types/form-data': 0.0.33 '@types/node': 8.10.66 - '@types/qs': 6.9.9 + '@types/qs': 6.9.18 caseless: 0.12.0 concat-stream: 1.6.2 - form-data: 2.5.1 + form-data: 2.5.2 http-basic: 8.1.3 http-response-object: 3.0.2 promise: 8.3.0 - qs: 6.11.2 + qs: 6.14.0 through2@4.0.2: dependencies: @@ -10591,9 +10763,13 @@ snapshots: trim-newlines@3.0.1: {} - ts-api-utils@1.3.0(typescript@5.5.3): + ts-api-utils@1.3.0(typescript@5.7.3): + dependencies: + typescript: 5.7.3 + + ts-api-utils@1.4.3(typescript@5.7.3): dependencies: - typescript: 5.5.3 + typescript: 5.7.3 ts-command-line-args@2.5.1: dependencies: @@ -10602,51 +10778,31 @@ snapshots: command-line-usage: 6.1.3 string-format: 2.0.0 - ts-essentials@7.0.3(typescript@5.5.3): - dependencies: - typescript: 5.5.3 - - ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3): + ts-essentials@7.0.3(typescript@5.7.3): dependencies: - '@cspotcode/source-map-support': 0.8.1 - '@tsconfig/node10': 1.0.9 - '@tsconfig/node12': 1.0.11 - '@tsconfig/node14': 1.0.3 - '@tsconfig/node16': 1.0.4 - '@types/node': 18.18.7 - acorn: 8.11.3 - acorn-walk: 8.3.2 - arg: 4.1.3 - create-require: 1.1.1 - diff: 4.0.2 - make-error: 1.3.6 - typescript: 5.5.3 - v8-compile-cache-lib: 3.0.1 - yn: 3.1.1 - optionalDependencies: - '@swc/core': 1.6.3 + typescript: 5.7.3 - ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.4): + ts-node@10.9.2(@swc/core@1.6.3)(@types/node@18.19.71)(typescript@5.7.3): dependencies: '@cspotcode/source-map-support': 0.8.1 '@tsconfig/node10': 1.0.9 '@tsconfig/node12': 1.0.11 '@tsconfig/node14': 1.0.3 '@tsconfig/node16': 1.0.4 - '@types/node': 18.18.7 + '@types/node': 18.19.71 acorn: 8.11.3 acorn-walk: 8.3.2 arg: 4.1.3 create-require: 1.1.1 diff: 4.0.2 make-error: 1.3.6 - typescript: 5.5.4 + typescript: 5.7.3 v8-compile-cache-lib: 3.0.1 yn: 3.1.1 optionalDependencies: '@swc/core': 1.6.3 - ts-node@10.9.1(@swc/core@1.6.3)(@types/node@20.5.1)(typescript@5.5.3): + ts-node@10.9.2(@swc/core@1.6.3)(@types/node@20.5.1)(typescript@5.7.3): dependencies: '@cspotcode/source-map-support': 0.8.1 '@tsconfig/node10': 1.0.9 @@ -10660,7 +10816,7 @@ snapshots: create-require: 1.1.1 diff: 4.0.2 make-error: 1.3.6 - typescript: 5.5.3 + typescript: 5.7.3 v8-compile-cache-lib: 3.0.1 yn: 3.1.1 optionalDependencies: @@ -10668,11 +10824,9 @@ snapshots: tslib@1.14.1: {} - tslib@2.4.0: {} + tslib@2.7.0: {} - tslib@2.6.2: {} - - tslog@4.9.3: {} + tslib@2.8.1: {} tsort@0.0.1: {} @@ -10731,7 +10885,7 @@ snapshots: type-fest@1.4.0: {} - typechain@8.3.2(typescript@5.5.3): + typechain@8.3.2(typescript@5.7.3): dependencies: '@types/prettier': 2.7.3 debug: 4.3.4(supports-color@8.1.1) @@ -10742,8 +10896,8 @@ snapshots: mkdirp: 1.0.4 prettier: 2.8.8 ts-command-line-args: 2.5.1 - ts-essentials: 7.0.3(typescript@5.5.3) - typescript: 5.5.3 + ts-essentials: 7.0.3(typescript@5.7.3) + typescript: 5.7.3 transitivePeerDependencies: - supports-color @@ -10781,15 +10935,13 @@ snapshots: typedarray@0.0.6: {} - typescript@5.5.3: {} - - typescript@5.5.4: {} + typescript@5.7.3: {} typical@4.0.0: {} typical@5.2.0: {} - uglify-js@3.17.4: + uglify-js@3.19.3: optional: true unbox-primitive@1.0.2: @@ -10801,10 +10953,16 @@ snapshots: undici-types@5.26.5: {} + undici-types@6.19.8: {} + undici@5.28.4: dependencies: '@fastify/busboy': 2.0.0 + undici@5.28.5: + dependencies: + '@fastify/busboy': 2.1.1 + undici@6.18.2: {} unfetch@4.2.0: {} @@ -10813,6 +10971,8 @@ snapshots: universalify@2.0.0: {} + universalify@2.0.1: {} + unpipe@1.0.0: {} update-browserslist-db@1.0.13(browserslist@4.22.1): @@ -10827,7 +10987,7 @@ snapshots: utf-8-validate@5.0.10: dependencies: - node-gyp-build: 4.6.1 + node-gyp-build: 4.8.4 optional: true utf8@3.0.0: {} @@ -10845,19 +11005,18 @@ snapshots: spdx-correct: 3.2.0 spdx-expression-parse: 3.0.1 - viem@2.19.7(bufferutil@4.0.8)(typescript@5.5.3)(utf-8-validate@5.0.10)(zod@3.23.8): + viem@2.22.10(bufferutil@4.0.8)(typescript@5.7.3)(utf-8-validate@5.0.10)(zod@3.23.8): dependencies: - '@adraffy/ens-normalize': 1.10.0 - '@noble/curves': 1.4.0 - '@noble/hashes': 1.4.0 - '@scure/bip32': 1.4.0 - '@scure/bip39': 1.3.0 - abitype: 1.0.5(typescript@5.5.3)(zod@3.23.8) - isows: 1.0.4(ws@8.17.1(bufferutil@4.0.8)(utf-8-validate@5.0.10)) - webauthn-p256: 0.0.5 - ws: 8.17.1(bufferutil@4.0.8)(utf-8-validate@5.0.10) + '@noble/curves': 1.7.0 + '@noble/hashes': 1.6.1 + '@scure/bip32': 1.6.0 + '@scure/bip39': 1.5.0 + abitype: 1.0.7(typescript@5.7.3)(zod@3.23.8) + isows: 1.0.6(ws@8.18.0(bufferutil@4.0.8)(utf-8-validate@5.0.10)) + ox: 0.6.5(typescript@5.7.3)(zod@3.23.8) + ws: 8.18.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) optionalDependencies: - typescript: 5.5.3 + typescript: 5.7.3 transitivePeerDependencies: - bufferutil - utf-8-validate @@ -10867,22 +11026,17 @@ snapshots: dependencies: defaults: 1.0.4 - web3-utils@1.10.3: + web3-utils@1.10.4: dependencies: '@ethereumjs/util': 8.1.0 bn.js: 5.2.1 - ethereum-bloom-filters: 1.0.10 - ethereum-cryptography: 2.1.2 + ethereum-bloom-filters: 1.2.0 + ethereum-cryptography: 2.2.1 ethjs-unit: 0.1.6 number-to-bn: 1.7.0 randombytes: 2.1.0 utf8: 3.0.0 - webauthn-p256@0.0.5: - dependencies: - '@noble/curves': 1.4.0 - '@noble/hashes': 1.4.0 - webidl-conversions@3.0.1: {} whatwg-url@5.0.0: @@ -10929,6 +11083,8 @@ snapshots: workerpool@6.2.1: {} + workerpool@6.5.1: {} + wrap-ansi@7.0.0: dependencies: ansi-styles: 4.3.0 @@ -10958,17 +11114,11 @@ snapshots: bufferutil: 4.0.8 utf-8-validate: 5.0.10 - ws@8.5.0(bufferutil@4.0.8)(utf-8-validate@5.0.10): + ws@8.18.0(bufferutil@4.0.8)(utf-8-validate@5.0.10): optionalDependencies: bufferutil: 4.0.8 utf-8-validate: 5.0.10 - xdeployer@2.1.13(@nomicfoundation/hardhat-ethers@3.0.8(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)))(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)): - dependencies: - '@nomicfoundation/hardhat-ethers': 3.0.8(ethers@6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10)) - ethers: 6.9.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) - hardhat: 2.22.18(bufferutil@4.0.8)(ts-node@10.9.1(@swc/core@1.6.3)(@types/node@18.18.7)(typescript@5.5.3))(typescript@5.5.3)(utf-8-validate@5.0.10) - y18n@5.0.8: {} yallist@3.1.1: {} @@ -11014,9 +11164,5 @@ snapshots: yocto-queue@0.1.0: {} - zksync-web3@0.14.4(ethers@5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10)): - dependencies: - ethers: 5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) - zod@3.23.8: optional: true