From b7d4fc1482fd53fcf00b65a8be73edde07ffebb2 Mon Sep 17 00:00:00 2001 From: 0xMasayoshi <0xmasayoshi@protonmail.com> Date: Mon, 4 Jul 2022 19:57:43 +0200 Subject: [PATCH] init Shoyu --- .gitignore | 20 + .prettierignore | 5 + README.md | 22 + config/.solcover.js | 24 + config/.solhint.json | 16 + config/.solhintignore | 6 + constants/addresses.ts | 13 + constants/constants.js | 96 + contracts/seaport/Conduit.sol | 4 + contracts/seaport/ConduitController.sol | 4 + .../ImmutableCreate2FactoryInterface.sol | 4 + contracts/seaport/Seaport.sol | 4 + contracts/shoyu/Shoyu.sol | 130 + .../shoyu/adapters/Markets/SeaportAdapter.sol | 48 + .../shoyu/adapters/Transfer/BentoAdapter.sol | 83 + .../adapters/Transfer/ConduitAdapter.sol | 141 + .../adapters/Transfer/TransferAdapter.sol | 132 + .../adapters/Transform/LegacySwapAdapter.sol | 122 + .../Transform/TransformationAdapter.sol | 85 + .../shoyu/interfaces/IAdapterRegistry.sol | 21 + contracts/shoyu/interfaces/IShoyu.sol | 33 + contracts/shoyu/lib/AdapterRegistry.sol | 43 + contracts/shoyu/lib/LibSushi.sol | 112 + contracts/shoyu/lib/ShoyuEnums.sol | 8 + contracts/shoyu/lib/ShoyuStructs.sol | 25 + contracts/sushiswap/BentoBoxV1.sol | 1155 ++ contracts/sushiswap/IBentoBoxMinimal.sol | 86 + .../sushiswap/uniswapv2/UniswapV2Factory.sol | 4 + .../sushiswap/uniswapv2/UniswapV2Router02.sol | 447 + .../uniswapv2/libraries/UniswapV2Library.sol | 86 + contracts/test/EIP1271Wallet.sol | 117 + contracts/test/Reenterer.sol | 35 + contracts/test/TestERC1155.sol | 20 + contracts/test/TestERC20.sol | 49 + contracts/test/TestERC721.sol | 16 + contracts/test/TestWETH.sol | 63 + contracts/test/TestZone.sol | 61 + deploy/Seaport.ts | 45 + deploy/Shoyu.ts | 102 + deploy/Sushiswap.ts | 52 + deploy/TestWETH.ts | 37 + deployments/goerli/.chainId | 1 + deployments/goerli/Seaport.json | 3196 +++++ eip-712-types/domain.js | 12 + eip-712-types/order.js | 34 + hardhat-coverage.config.ts | 40 + hardhat.config.ts | 138 + package.json | 138 + remappings.txt | 4 + scripts/conduit.ts | 47 + test/index.test.ts | 2414 ++++ test/utils/contracts.ts | 27 + test/utils/contsants.ts | 11 + test/utils/criteria.js | 105 + test/utils/encoding.ts | 376 + test/utils/fixtures/conduit.ts | 116 + test/utils/fixtures/create2.ts | 73 + test/utils/fixtures/index.ts | 976 ++ test/utils/fixtures/marketplace.ts | 476 + test/utils/fixtures/seedSushiswapPools.ts | 69 + test/utils/fixtures/shoyuFixture.ts | 71 + test/utils/fixtures/tokens.ts | 301 + test/utils/helpers.ts | 38 + test/utils/impersonate.ts | 42 + test/utils/seeded-rng.js | 279 + test/utils/sign.ts | 0 test/utils/types.ts | 92 + tsconfig.json | 13 + yarn.lock | 11346 ++++++++++++++++ 69 files changed, 24011 insertions(+) create mode 100644 .gitignore create mode 100644 .prettierignore create mode 100644 README.md create mode 100644 config/.solcover.js create mode 100644 config/.solhint.json create mode 100644 config/.solhintignore create mode 100644 constants/addresses.ts create mode 100644 constants/constants.js create mode 100644 contracts/seaport/Conduit.sol create mode 100644 contracts/seaport/ConduitController.sol create mode 100644 contracts/seaport/ImmutableCreate2FactoryInterface.sol create mode 100644 contracts/seaport/Seaport.sol create mode 100644 contracts/shoyu/Shoyu.sol create mode 100644 contracts/shoyu/adapters/Markets/SeaportAdapter.sol create mode 100644 contracts/shoyu/adapters/Transfer/BentoAdapter.sol create mode 100644 contracts/shoyu/adapters/Transfer/ConduitAdapter.sol create mode 100644 contracts/shoyu/adapters/Transfer/TransferAdapter.sol create mode 100644 contracts/shoyu/adapters/Transform/LegacySwapAdapter.sol create mode 100644 contracts/shoyu/adapters/Transform/TransformationAdapter.sol create mode 100644 contracts/shoyu/interfaces/IAdapterRegistry.sol create mode 100644 contracts/shoyu/interfaces/IShoyu.sol create mode 100644 contracts/shoyu/lib/AdapterRegistry.sol create mode 100644 contracts/shoyu/lib/LibSushi.sol create mode 100644 contracts/shoyu/lib/ShoyuEnums.sol create mode 100644 contracts/shoyu/lib/ShoyuStructs.sol create mode 100644 contracts/sushiswap/BentoBoxV1.sol create mode 100644 contracts/sushiswap/IBentoBoxMinimal.sol create mode 100644 contracts/sushiswap/uniswapv2/UniswapV2Factory.sol create mode 100644 contracts/sushiswap/uniswapv2/UniswapV2Router02.sol create mode 100644 contracts/sushiswap/uniswapv2/libraries/UniswapV2Library.sol create mode 100644 contracts/test/EIP1271Wallet.sol create mode 100644 contracts/test/Reenterer.sol create mode 100644 contracts/test/TestERC1155.sol create mode 100644 contracts/test/TestERC20.sol create mode 100644 contracts/test/TestERC721.sol create mode 100644 contracts/test/TestWETH.sol create mode 100644 contracts/test/TestZone.sol create mode 100644 deploy/Seaport.ts create mode 100644 deploy/Shoyu.ts create mode 100644 deploy/Sushiswap.ts create mode 100644 deploy/TestWETH.ts create mode 100644 deployments/goerli/.chainId create mode 100644 deployments/goerli/Seaport.json create mode 100644 eip-712-types/domain.js create mode 100644 eip-712-types/order.js create mode 100644 hardhat-coverage.config.ts create mode 100644 hardhat.config.ts create mode 100644 package.json create mode 100644 remappings.txt create mode 100644 scripts/conduit.ts create mode 100644 test/index.test.ts create mode 100644 test/utils/contracts.ts create mode 100644 test/utils/contsants.ts create mode 100644 test/utils/criteria.js create mode 100644 test/utils/encoding.ts create mode 100644 test/utils/fixtures/conduit.ts create mode 100644 test/utils/fixtures/create2.ts create mode 100644 test/utils/fixtures/index.ts create mode 100644 test/utils/fixtures/marketplace.ts create mode 100644 test/utils/fixtures/seedSushiswapPools.ts create mode 100644 test/utils/fixtures/shoyuFixture.ts create mode 100644 test/utils/fixtures/tokens.ts create mode 100644 test/utils/helpers.ts create mode 100644 test/utils/impersonate.ts create mode 100644 test/utils/seeded-rng.js create mode 100644 test/utils/sign.ts create mode 100644 test/utils/types.ts create mode 100644 tsconfig.json create mode 100644 yarn.lock diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..b20ee139 --- /dev/null +++ b/.gitignore @@ -0,0 +1,20 @@ +node_modules +.env +coverage +coverage.json +typechain-types +yarn-error.log + +#Hardhat files +artifacts/ +hh-cache/ + + +.DS_Store + +# VScode +.vscode +__pycache__ + +.openzeppelin + diff --git a/.prettierignore b/.prettierignore new file mode 100644 index 00000000..f268596e --- /dev/null +++ b/.prettierignore @@ -0,0 +1,5 @@ +node_modules +artifacts +cache +coverage* +gasReporterOutput.json diff --git a/README.md b/README.md new file mode 100644 index 00000000..12ffb492 --- /dev/null +++ b/README.md @@ -0,0 +1,22 @@ +# Shoyu + +Shoyu + +## Install + +To install dependencies and compile contracts: + +```bash +git clone https://github.com/ProjectOpenSea/seaport && cd seaport +yarn install +yarn build +``` + +## Usage + +To run hardhat tests written in javascript: + +```bash +yarn test +yarn coverage +``` diff --git a/config/.solcover.js b/config/.solcover.js new file mode 100644 index 00000000..f180a043 --- /dev/null +++ b/config/.solcover.js @@ -0,0 +1,24 @@ +module.exports = { + skipFiles: [ + "seaport/Conduit.sol", + "seaport/ConduitController.sol", + "seaport/ImmutableCreate2FactoryInterface.sol", + "seaport/Seaport.sol", + "test/EIP1271Wallet.sol", + "test/ExcessReturnDataRecipient.sol", + "test/ERC1155BatchRecipient.sol", + "test/Reenterer.sol", + "test/TestERC1155.sol", + "test/TestERC20.sol", + "test/TestERC721.sol", + "test/TestZone.sol", + "test/TestWETH.sol" + ], + configureYulOptimizer: true, + solcOptimizerDetails: { + yul: true, + yulDetails: { + stackAllocation: true, + }, + }, +}; diff --git a/config/.solhint.json b/config/.solhint.json new file mode 100644 index 00000000..a555b9d0 --- /dev/null +++ b/config/.solhint.json @@ -0,0 +1,16 @@ +{ + "extends": "solhint:all", + "rules": { + "compiler-version": ["error", ">=0.8.7"], + "func-visibility": ["warn", { "ignoreConstructors": true }], + "no-empty-blocks": "off", + "no-inline-assembly": "off", + "avoid-low-level-calls": "off", + "not-rely-on-time": "off", + "var-name-mixedcase": "off", + "func-name-mixedcase": "off", + "max-line-length": ["warn", 80], + "function-max-lines": "off", + "code-complexity": ["warn", 15] + } +} diff --git a/config/.solhintignore b/config/.solhintignore new file mode 100644 index 00000000..8d4fb424 --- /dev/null +++ b/config/.solhintignore @@ -0,0 +1,6 @@ +node_modules/ + +contracts/test/ + +test/ +lib/ \ No newline at end of file diff --git a/constants/addresses.ts b/constants/addresses.ts new file mode 100644 index 00000000..c4c13244 --- /dev/null +++ b/constants/addresses.ts @@ -0,0 +1,13 @@ +import { ChainId } from "@sushiswap/core-sdk"; + +export const CONDUIT_CONTROLLER_ADDRESS: { [chainId: number]: string } = { + [ChainId.ETHEREUM]: "0x00000000006ce100a8b5ed8edf18ceef9e500697", + [ChainId.RINKEBY]: "0x00000000006ce100a8b5ed8edf18ceef9e500697", + [ChainId.GÖRLI]: "0x00000000006ce100a8b5ed8edf18ceef9e500697", +}; + +export const SEAPORT_ADDRESS: { [chainId: number]: string } = { + [ChainId.ETHEREUM]: "0x00000000006c3852cbef3e08e8df289169ede581", + [ChainId.RINKEBY]: "0x00000000006c3852cbef3e08e8df289169ede581", + [ChainId.GÖRLI]: "0x00000000006c3852cbEf3e08E8dF289169EdE581", +}; diff --git a/constants/constants.js b/constants/constants.js new file mode 100644 index 00000000..3950a547 --- /dev/null +++ b/constants/constants.js @@ -0,0 +1,96 @@ +module.exports = Object.freeze({ + KEYLESS_CREATE2_DEPLOYER_ADDRESS: + "0x4c8D290a1B368ac4728d83a9e8321fC3af2b39b1", + KEYLESS_CREATE2_DEPLOYMENT_TRANSACTION: + "0xf87e8085174876e800830186a08080ad601f80600e600039806000f350fe600036" + + "81823780368234f58015156014578182fd5b80825250506014600cf31ba022222222" + + "22222222222222222222222222222222222222222222222222222222a02222222222" + + "222222222222222222222222222222222222222222222222222222", + KEYLESS_CREATE2_ADDRESS: "0x7A0D94F55792C434d74a40883C6ed8545E406D12", + KEYLESS_CREATE2_RUNTIME_CODE: + "0x60003681823780368234f58015156014578182fd5b80825250506014600cf3", + KEYLESS_CREATE2_RUNTIME_HASH: + "0x60003681823780368234f58015156014578182fd5b80825250506014600cf3", + INEFFICIENT_IMMUTABLE_CREATE2_FACTORY_ADDRESS: + "0xcfA3A7637547094fF06246817a35B8333C315196", + IMMUTABLE_CREATE2_FACTORY_ADDRESS: + "0x0000000000FFe8B47B3e2130213B802212439497", + IMMUTABLE_CREATE2_FACTORY_SALT: + "0x0000000000000000000000000000000000000000f4b0218f13a6440a6f020000", + IMMUTABLE_CREATE2_FACTORY_CREATION_CODE: + "0x608060405234801561001057600080fd5b50610833806100206000396000f3fe60" + + "806040526004361061003f5760003560e01c806308508b8f1461004457806364e030" + + "871461009857806385cf97ab14610138578063a49a7c90146101bc575b600080fd5b" + + "34801561005057600080fd5b506100846004803603602081101561006757600080fd" + + "5b503573ffffffffffffffffffffffffffffffffffffffff166101ec565b60408051" + + "9115158252519081900360200190f35b61010f600480360360408110156100ae5760" + + "0080fd5b813591908101906040810160208201356401000000008111156100d05760" + + "0080fd5b8201836020820111156100e257600080fd5b803590602001918460018302" + + "8401116401000000008311171561010457600080fd5b509092509050610217565b60" + + "40805173ffffffffffffffffffffffffffffffffffffffff90921682525190819003" + + "60200190f35b34801561014457600080fd5b5061010f600480360360408110156101" + + "5b57600080fd5b813591908101906040810160208201356401000000008111156101" + + "7d57600080fd5b82018360208201111561018f57600080fd5b803590602001918460" + + "018302840111640100000000831117156101b157600080fd5b509092509050610592" + + "565b3480156101c857600080fd5b5061010f600480360360408110156101df576000" + + "80fd5b508035906020013561069e565b73ffffffffffffffffffffffffffffffffff" + + "ffffff1660009081526020819052604090205460ff1690565b600083606081901c33" + + "148061024c57507fffffffffffffffffffffffffffffffffffffffff000000000000" + + "0000000000008116155b6102a1576040517f08c379a0000000000000000000000000" + + "00000000000000000000000000000000815260040180806020018281038252604581" + + "52602001806107746045913960600191505060405180910390fd5b60608484808060" + + "1f016020809104026020016040519081016040528093929190818152602001838380" + + "8284376000920182905250604051855195965090943094508b935086925060209182" + + "01918291908401908083835b6020831061033557805182527fffffffffffffffffff" + + "ffffffffffffffffffffffffffffffffffffffffffffe09092019160209182019101" + + "6102f8565b51815160209384036101000a7fffffffffffffffffffffffffffffffff" + + "ffffffffffffffffffffffffffffffff018019909216911617905260408051929094" + + "018281037fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" + + "ffffe00183528085528251928201929092207fff0000000000000000000000000000" + + "00000000000000000000000000000000008383015260609890981b7fffffffffffff" + + "ffffffffffffffffffffffffffff0000000000000000000000001660218301526035" + + "82019690965260558082019790975282518082039097018752607501825250845194" + + "84019490942073ffffffffffffffffffffffffffffffffffffffff81166000908152" + + "938490529390922054929350505060ff16156104a7576040517f08c379a000000000" + + "00000000000000000000000000000000000000000000000081526004018080602001" + + "8281038252603f815260200180610735603f913960400191505060405180910390fd" + + "5b81602001825188818334f5955050508073ffffffffffffffffffffffffffffffff" + + "ffffffff168473ffffffffffffffffffffffffffffffffffffffff161461053a5760" + + "40517f08c379a0000000000000000000000000000000000000000000000000000000" + + "0081526004018080602001828103825260468152602001806107b960469139606001" + + "91505060405180910390fd5b50505073ffffffffffffffffffffffffffffffffffff" + + "ffff8116600090815260208190526040902080547fffffffffffffffffffffffffff" + + "ffffffffffffffffffffffffffffffffffff001660011790559392505050565b6000" + + "308484846040516020018083838082843760408051919093018181037fffffffffff" + + "ffffffffffffffffffffffffffffffffffffffffffffffffffffe001825280845281" + + "516020928301207fff00000000000000000000000000000000000000000000000000" + + "0000000000008383015260609990991b7fffffffffffffffffffffffffffffffffff" + + "ffffff00000000000000000000000016602182015260358101979097526055808801" + + "9890985282518088039098018852607590960182525085519585019590952073ffff" + + "ffffffffffffffffffffffffffffffffffff81166000908152948590529490932054" + + "939450505060ff909116159050610697575060005b9392505050565b604080517fff" + + "00000000000000000000000000000000000000000000000000000000000000602080" + + "8301919091523060601b602183015260358201859052605580830185905283518084" + + "0390910181526075909201835281519181019190912073ffffffffffffffffffffff" + + "ffffffffffffffffff81166000908152918290529190205460ff161561072e575060" + + "005b9291505056fe496e76616c696420636f6e7472616374206372656174696f6e20" + + "2d20636f6e74726163742068617320616c7265616479206265656e206465706c6f79" + + "65642e496e76616c69642073616c74202d206669727374203230206279746573206f" + + "66207468652073616c74206d757374206d617463682063616c6c696e672061646472" + + "6573732e4661696c656420746f206465706c6f7920636f6e7472616374207573696e" + + "672070726f76696465642073616c7420616e6420696e697469616c697a6174696f6e" + + "20636f64652ea265627a7a723058202bdc55310d97c4088f18acf04253db593f0914" + + "059f0c781a9df3624dcef0d1cf64736f6c634300050a0032", + IMMUTABLE_CREATE2_FACTORY_RUNTIME_HASH: + "0x767db8f19b71e367540fa372e8e81e4dcb7ca8feede0ae58a0c0bd08b7320dee", + CONDUIT_CONTROLLER_CREATION_HASH: + "0x78dcd34ae05f701d578e1495cd9f254e60e28883bd1e921917c12141daa2d45a", + CONDUIT_CONTROLLER_CREATION_SALT: + "0x00000000000000000000000000000000000000003b7dcb354e842802b5060000", + CONDUIT_CONTROLLER_ADDRESS: "0x00000000006cE100a8b5eD8eDf18ceeF9e500697", + MARKETPLACE_CONTRACT_CREATION_HASH: + "0x5161158f3bd737116360d9468eb4cf10436e07754e823d48f9f081e9f17cff43", + MARKETPLACE_CONTRACT_CREATION_SALT: + "0x00000000000000000000000000000000000000000db1a5942723530096000000", + MARKETPLACE_CONTRACT_ADDRESS: "0x00000000006CEE72100D161c57ADA5Bb2be1CA79", +}); diff --git a/contracts/seaport/Conduit.sol b/contracts/seaport/Conduit.sol new file mode 100644 index 00000000..ece0dac7 --- /dev/null +++ b/contracts/seaport/Conduit.sol @@ -0,0 +1,4 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.8.13; + +import "seaport/contracts/conduit/Conduit.sol"; \ No newline at end of file diff --git a/contracts/seaport/ConduitController.sol b/contracts/seaport/ConduitController.sol new file mode 100644 index 00000000..b637fffb --- /dev/null +++ b/contracts/seaport/ConduitController.sol @@ -0,0 +1,4 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.8.13; + +import "seaport/contracts/conduit/ConduitController.sol"; \ No newline at end of file diff --git a/contracts/seaport/ImmutableCreate2FactoryInterface.sol b/contracts/seaport/ImmutableCreate2FactoryInterface.sol new file mode 100644 index 00000000..1e8a3185 --- /dev/null +++ b/contracts/seaport/ImmutableCreate2FactoryInterface.sol @@ -0,0 +1,4 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.8.13; + +import "seaport/contracts/interfaces/ImmutableCreate2FactoryInterface.sol"; \ No newline at end of file diff --git a/contracts/seaport/Seaport.sol b/contracts/seaport/Seaport.sol new file mode 100644 index 00000000..53aa2408 --- /dev/null +++ b/contracts/seaport/Seaport.sol @@ -0,0 +1,4 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.8.13; + +import "seaport/contracts/Seaport.sol"; \ No newline at end of file diff --git a/contracts/shoyu/Shoyu.sol b/contracts/shoyu/Shoyu.sol new file mode 100644 index 00000000..27b7efab --- /dev/null +++ b/contracts/shoyu/Shoyu.sol @@ -0,0 +1,130 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.8.13; + +import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; +import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; +import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; +import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol"; +import "@rari-capital/solmate/src/tokens/ERC20.sol"; +import "@rari-capital/solmate/src/tokens/ERC721.sol"; +import "@rari-capital/solmate/src/tokens/ERC1155.sol"; +import "./interfaces/IShoyu.sol"; +import "./lib/AdapterRegistry.sol"; +import "../sushiswap/IBentoBoxMinimal.sol"; + +contract Shoyu is Initializable, UUPSUpgradeable, OwnableUpgradeable, PausableUpgradeable { + AdapterRegistry public adapterRegistry; + + function initialize(address _adapterRegistery, address _bentobox) initializer public { + adapterRegistry = AdapterRegistry(_adapterRegistery); + IBentoBoxMinimal(_bentobox).registerProtocol(); + + __Ownable_init(); + } + + function cook( + uint8[] calldata adapterIds, + uint256[] calldata values, + bytes[] calldata datas + ) external payable whenNotPaused { + uint256 length = adapterIds.length; + for (uint256 i; i < length; ++i) { + ( + address adapterAddress, + bool isLibrary, + bool isActive + ) = adapterRegistry.adapters(adapterIds[i]); + + require(isActive, "cook: inactive adapter"); + + (bool success, ) = isLibrary ? adapterAddress.delegatecall(datas[i]) + : adapterAddress.call{value: values[i]}(datas[i]); + + if (!success) { + assembly { + returndatacopy(0, 0, returndatasize()) + revert(0, returndatasize()) + } + } + } + + _refundExcessETH(); + } + + function _transferETH(address to, uint256 amount) internal { + assembly { + let success := call(gas(), to, amount, 0, 0, 0, 0) + if eq(success, 0) { revert(0, 0) } + } + } + + function _refundExcessETH() internal { + uint256 balance = address(this).balance; + if (balance > 0) { + _transferETH(msg.sender, balance); + } + } + + function approveERC20( + address token, + address operator, + uint256 amount + ) external onlyOwner { + ERC20(token).approve(operator, amount); + } + + function retrieveETH(address to, uint256 amount) onlyOwner external { + _transferETH(to, amount); + } + + function retrieveERC20(address token, address to, uint256 amount) onlyOwner external { + ERC20(token).transfer(to, amount); + } + + function retrieveERC721( + address token, + uint256[] calldata tokenIds, + address to + ) onlyOwner external { + uint256 length = tokenIds.length; + for (uint256 i; i < length; ++i) { + ERC721(token).safeTransferFrom(address(this), to, tokenIds[i]); + } + } + + function retrieveERC1155( + address token, + uint256[] calldata tokenIds, + uint256[] calldata amounts, + address to + ) onlyOwner external { + ERC1155(token).safeBatchTransferFrom(address(this), to, tokenIds, amounts, ""); + } + + /// @dev Fallback for just receiving ether. + receive() external payable {} + + /// @dev Allows this contract to receive ERC1155 tokens + function onERC1155Received( + address, + address, + uint256, + uint256, + bytes calldata + ) public virtual returns (bytes4) { + return this.onERC1155Received.selector; + } + + function onERC1155BatchReceived( + address, + address, + uint256[] calldata, + uint256[] calldata, + bytes calldata + ) public virtual returns (bytes4) { + return this.onERC1155BatchReceived.selector; + } + + /// @dev Required by UUPSUpgradeable + function _authorizeUpgrade(address) internal override onlyOwner {} +} diff --git a/contracts/shoyu/adapters/Markets/SeaportAdapter.sol b/contracts/shoyu/adapters/Markets/SeaportAdapter.sol new file mode 100644 index 00000000..f9b10fa7 --- /dev/null +++ b/contracts/shoyu/adapters/Markets/SeaportAdapter.sol @@ -0,0 +1,48 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.8.11; + +import "@rari-capital/solmate/src/tokens/ERC721.sol"; + +contract SeaportAdapter { + address public immutable seaportAddress; + + constructor(address _seaportAddress) { + seaportAddress = _seaportAddress; + } + + function approveBeforeFulfill ( + address[] calldata tokensToApprove, + uint256 ethAmount, + bytes calldata data + ) external payable returns (bool success, bytes memory returnData) { + uint256 length = tokensToApprove.length; + for (uint256 i; i < length; ++i) { + if (!ERC721(tokensToApprove[i]).isApprovedForAll(address(this), seaportAddress)) { + ERC721(tokensToApprove[i]).setApprovalForAll(seaportAddress, true); + } + } + + (success, returnData) = seaportAddress.call{value: ethAmount}(data); + + if (!success) { + assembly { + returndatacopy(0, 0, returndatasize()) + revert(0, returndatasize()) + } + } + } + + function fulfill ( + uint256 ethAmount, + bytes calldata data + ) external payable returns (bool success, bytes memory returnData) { + (success, returnData) = seaportAddress.call{value: ethAmount}(data); + + if (!success) { + assembly { + returndatacopy(0, 0, returndatasize()) + revert(0, returndatasize()) + } + } + } +} \ No newline at end of file diff --git a/contracts/shoyu/adapters/Transfer/BentoAdapter.sol b/contracts/shoyu/adapters/Transfer/BentoAdapter.sol new file mode 100644 index 00000000..3353c2db --- /dev/null +++ b/contracts/shoyu/adapters/Transfer/BentoAdapter.sol @@ -0,0 +1,83 @@ +// SPDX-License-Identifier: GPL-3.0-or-later + +pragma solidity >=0.8.11; + +import "@rari-capital/solmate/src/tokens/ERC20.sol"; +import "../../../sushiswap/IBentoBoxMinimal.sol"; + +/// @title BentoAdapter +/// @notice Adapter which provides all functions of BentoBox require by this contract. +/// @dev These are generic functions, make sure, only msg.sender, address(this) and address(bentoBox) +/// are passed in the from param, or else the attacker can sifu user's funds in bentobox. +abstract contract BentoAdapter { + IBentoBoxMinimal public immutable bentoBox; + + constructor(address _bentoBox) { + bentoBox = IBentoBoxMinimal(_bentoBox); + } + + // deposits funds from address(this) into bentobox + function depositToBentoBox( + bool approve, + address token, + address to, + uint256 amount, + uint256 share, + uint256 value + ) public { + if (approve) { + ERC20(token).approve(address(bentoBox), type(uint256).max); + } + + bentoBox.deposit{value: value}(token, address(this), to, amount, share); + } + + /// @notice Deposits the token from users wallet into the BentoBox. + /// @dev Make sure, only msg.sender, address(this) and address(bentoBox) + /// are passed in the from param, or else the attacker can sifu user's funds in bentobox. + /// Pass either amount or share. + /// @param token token to deposit. Use token as address(0) when depositing native token + /// @param from sender + /// @param to receiver + /// @param amount amount to be deposited + /// @param share share to be deposited + /// @param value native token value to be deposited. Only use when token address is address(0) + function _depositToBentoBox( + address token, + address from, + address to, + uint256 amount, + uint256 share, + uint256 value + ) internal { + bentoBox.deposit{value: value}(token, from, to, amount, share); + } + + /// @notice Transfers the token from bentobox user to another or withdraw it to another address. + /// @dev Make sure, only msg.sender, address(this) and address(bentoBox) + /// are passed in the from param, or else the attacker can sifu user's funds in bentobox. + /// Pass either amount or share. + /// @param token token to transfer. For native tokens, use wnative token address + /// @param from sender + /// @param to receiver + /// @param amount amount to transfer + /// @param share share to transfer + /// @param unwrapBento use true for withdraw and false for transfer + function _transferFromBentoBox( + address token, + address from, + address to, + uint256 amount, + uint256 share, + bool unwrapBento + ) internal { + if (unwrapBento) { + bentoBox.withdraw(token, from, to, amount, share); + } else { + if (amount > 0) { + share = bentoBox.toShare(token, amount, false); + } + bentoBox.transfer(token, from, to, share); + } + } +} diff --git a/contracts/shoyu/adapters/Transfer/ConduitAdapter.sol b/contracts/shoyu/adapters/Transfer/ConduitAdapter.sol new file mode 100644 index 00000000..a0ac36ae --- /dev/null +++ b/contracts/shoyu/adapters/Transfer/ConduitAdapter.sol @@ -0,0 +1,141 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.8.7; + +import { ConduitControllerInterface } from "seaport/contracts/interfaces/ConduitControllerInterface.sol"; +import { ConduitInterface } from "seaport/contracts/interfaces/ConduitInterface.sol"; +import { ConduitTransfer } from "seaport/contracts/conduit/lib/ConduitStructs.sol"; +import { ConduitItemType } from "seaport/contracts/conduit/lib/ConduitEnums.sol"; + +contract ConduitAdapter { + // Allow for interaction with the conduit controller. + ConduitControllerInterface private immutable _CONDUIT_CONTROLLER; + // Cache the conduit creation hash used by the conduit controller. + bytes32 private immutable _CONDUIT_CREATION_CODE_HASH; + + constructor(address _conduitController) { + // Get the conduit creation code hash from the supplied conduit + // controller and set it as an immutable. + ConduitControllerInterface conduitController = ConduitControllerInterface( + _conduitController + ); + (_CONDUIT_CREATION_CODE_HASH, ) = conduitController.getConduitCodeHashes(); + + // Set the supplied conduit controller as an immutable. + _CONDUIT_CONTROLLER = conduitController; + } + + function _performERC20TransferWithConduit( + address token, + address from, + address to, + uint256 amount, + bytes32 conduitKey + ) internal { + // Derive the conduit address from the deployer, conduit key + // and creation code hash. + address conduit = address( + uint160( + uint256( + keccak256( + abi.encodePacked( + bytes1(0xff), + address(_CONDUIT_CONTROLLER), + conduitKey, + _CONDUIT_CREATION_CODE_HASH + ) + ) + ) + ) + ); + + ConduitTransfer[] memory conduitTransfers = new ConduitTransfer[](1); + conduitTransfers[0] = ConduitTransfer( + ConduitItemType.ERC20, + token, + from, + to, + 0, + amount + ); + + // Call the conduit and execute transfer. + ConduitInterface(conduit).execute(conduitTransfers); + } + + function _performERC721TransferWithConduit( + address token, + address from, + address to, + uint256 tokenId, + bytes32 conduitKey + ) internal { + // Derive the conduit address from the deployer, conduit key + // and creation code hash. + address conduit = address( + uint160( + uint256( + keccak256( + abi.encodePacked( + bytes1(0xff), + address(_CONDUIT_CONTROLLER), + conduitKey, + _CONDUIT_CREATION_CODE_HASH + ) + ) + ) + ) + ); + + ConduitTransfer[] memory conduitTransfers = new ConduitTransfer[](1); + conduitTransfers[0] = ConduitTransfer( + ConduitItemType.ERC721, + token, + from, + to, + tokenId, + 1 + ); + + // Call the conduit and execute transfer. + ConduitInterface(conduit).execute(conduitTransfers); + } + + function _performERC1155TransferWithConduit( + address token, + address from, + address to, + uint256 tokenId, + uint256 amount, + bytes32 conduitKey + ) internal { + // Derive the conduit address from the deployer, conduit key + // and creation code hash. + address conduit = address( + uint160( + uint256( + keccak256( + abi.encodePacked( + bytes1(0xff), + address(_CONDUIT_CONTROLLER), + conduitKey, + _CONDUIT_CREATION_CODE_HASH + ) + ) + ) + ) + ); + + ConduitTransfer[] memory conduitTransfers = new ConduitTransfer[](1); + conduitTransfers[0] = ConduitTransfer( + ConduitItemType.ERC1155, + token, + from, + to, + tokenId, + amount + ); + + // Call the conduit and execute transfer. + ConduitInterface(conduit).execute(conduitTransfers); + } +} \ No newline at end of file diff --git a/contracts/shoyu/adapters/Transfer/TransferAdapter.sol b/contracts/shoyu/adapters/Transfer/TransferAdapter.sol new file mode 100644 index 00000000..0181c2f6 --- /dev/null +++ b/contracts/shoyu/adapters/Transfer/TransferAdapter.sol @@ -0,0 +1,132 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.8.7; + +import "seaport/contracts/lib/TokenTransferrer.sol"; +import "./ConduitAdapter.sol"; +import "./BentoAdapter.sol"; +import { TokenSource } from "../../lib/ShoyuEnums.sol"; + +// TODO: Consider notice in TokenTransferrer.sol, maybe it shouldn't be used here +contract TransferAdapter is TokenTransferrer, ConduitAdapter, BentoAdapter { + constructor( + address _conduitController, + address _bentoBox + ) + ConduitAdapter(_conduitController) + BentoAdapter(_bentoBox) + {} + + function transferERC20From( + address token, + address to, + uint256 amount, + TokenSource source, + bytes memory data + ) public { + if (source == TokenSource.WALLET) { + _performERC20Transfer( + token, + msg.sender, + to, + amount + ); + } else if (source == TokenSource.CONDUIT) { + bytes32 conduitKey = abi.decode(data, (bytes32)); + + _performERC20TransferWithConduit( + token, + msg.sender, + to, + amount, + conduitKey + ); + } else if (source == TokenSource.BENTO) { + bool unwrapBento = abi.decode(data, (bool)); + + _transferFromBentoBox( + token, + msg.sender, + to, + amount, + 0, + unwrapBento + ); + } else { + revert("transferERC20From/INVALID_TOKEN_SOURCE"); + } + } + + function transferERC721From( + address token, + address to, + uint256 tokenId, + TokenSource source, + bytes memory data + ) public { + if (source == TokenSource.WALLET) { + _performERC721Transfer( + token, + msg.sender, + to, + tokenId + ); + } else if (source == TokenSource.CONDUIT) { + bytes32 conduitKey = abi.decode(data, (bytes32)); + + _performERC721TransferWithConduit( + token, + msg.sender, + to, + tokenId, + conduitKey + ); + } else { + revert("transferERC721From/INVALID_TOKEN_SOURCE"); + } + } + + function transferERC1155From( + address token, + address to, + uint256 tokenId, + uint256 amount, + TokenSource source, + bytes memory data + ) public { + if (source == TokenSource.WALLET) { + _performERC1155Transfer( + token, + msg.sender, + to, + tokenId, + amount + ); + } else if (source == TokenSource.CONDUIT) { + bytes32 conduitKey = abi.decode(data, (bytes32)); + + _performERC1155TransferWithConduit( + token, + msg.sender, + to, + tokenId, + amount, + conduitKey + ); + } else { + revert("transferERC1155From/INVALID_TOKEN_SOURCE"); + } + } + + /// @dev Transfers some amount of ETH to the given recipient and + /// reverts if the transfer fails. + /// @param to The recipient of the ETH. + /// @param amount The amount of ETH to transfer. + function _transferEth(address payable to, uint256 amount) + internal + { + assembly { + let success := call(gas(), to, amount, 0, 0, 0, 0) + if eq(success, 0) { revert(0, 0) } + } + } +} \ No newline at end of file diff --git a/contracts/shoyu/adapters/Transform/LegacySwapAdapter.sol b/contracts/shoyu/adapters/Transform/LegacySwapAdapter.sol new file mode 100644 index 00000000..23387e23 --- /dev/null +++ b/contracts/shoyu/adapters/Transform/LegacySwapAdapter.sol @@ -0,0 +1,122 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.8.7; + +import "@sushiswap/core/contracts/uniswapv2/interfaces/IUniswapV2Pair.sol"; +import "@rari-capital/solmate/src/tokens/ERC20.sol"; + +import "../Transfer/ConduitAdapter.sol"; +import "../Transfer/TransferAdapter.sol"; +import { SwapExactOutDetails } from "../../lib/ShoyuStructs.sol"; +import { pairFor, sortTokens, getAmountsIn, getAmountsOut } from "../../lib/LibSushi.sol"; +import { TokenSource } from "../../lib/ShoyuEnums.sol"; + +contract LegacySwapAdapter is TransferAdapter { + /// @dev The UniswapV2Factory address. + address private immutable factory; + /// @dev The UniswapV2 pair init code. + bytes32 private immutable pairCodeHash; + + constructor( + address _factory, + bytes32 _pairCodeHash, + address _conduitController, + address _bentobox + ) TransferAdapter (_conduitController, _bentobox) { + factory = _factory; + pairCodeHash = _pairCodeHash; + } + + // transfers funds from msg.sender and performs swap + function _legacySwapExactOut( + uint256 amountOut, + uint256 amountInMax, + address[] memory path, + address to, + TokenSource tokenSource, + bytes memory transferData + ) internal returns (uint256 amountIn) { + uint256[] memory amounts = getAmountsIn( + factory, + amountOut, + path, + pairCodeHash + ); + amountIn = amounts[0]; + + require(amountIn <= amountInMax, '_legacySwapExactOut/EXCESSIVE_AMOUNT_IN'); + + transferERC20From( + path[0], + pairFor( + factory, + path[0], + path[1], + pairCodeHash + ), + amountIn, + tokenSource, + transferData + ); + + _swap(amounts, path, to); + } + + // requires path[0] to have already been sent to address(this) + function _legacySwapExactIn( + uint256 amountIn, + uint256 amountOutMin, + address[] memory path, + address to + ) internal returns (uint256 amountOut) { + uint256[] memory amounts = getAmountsOut( + factory, + amountIn, + path, + pairCodeHash + ); + amountOut = amounts[amounts.length - 1]; + + require(amountOut >= amountOutMin, "_legacySwapExactIn/EXCESSIVE_AMOUNT_OUT"); + + ERC20(path[0]).transfer( + pairFor( + factory, + path[0], + path[1], + pairCodeHash + ), + amountIn + ); + + _swap(amounts, path, to); + } + + // requires the initial amount to have already been sent to the first pair + function _swap( + uint256[] memory amounts, + address[] memory path, + address _to + ) internal virtual { + for (uint256 i; i < path.length - 1; i++) { + (address input, address output) = (path[i], path[i + 1]); + + (address token0, ) = sortTokens(input, output); + + uint256 amountOut = amounts[i + 1]; + + (uint256 amount0Out, uint256 amount1Out) = input == token0 + ? (uint256(0), amountOut) + : (amountOut, uint256(0)); + address to = i < path.length - 2 ? pairFor(factory, output, path[i + 2], pairCodeHash) : _to; + + IUniswapV2Pair(pairFor(factory, input, output, pairCodeHash)).swap( + amount0Out, + amount1Out, + to, + new bytes(0) + ); + } + } + + +} \ No newline at end of file diff --git a/contracts/shoyu/adapters/Transform/TransformationAdapter.sol b/contracts/shoyu/adapters/Transform/TransformationAdapter.sol new file mode 100644 index 00000000..8f0747eb --- /dev/null +++ b/contracts/shoyu/adapters/Transform/TransformationAdapter.sol @@ -0,0 +1,85 @@ +pragma solidity >=0.8.11; + +import "@sushiswap/core/contracts/uniswapv2/interfaces/IWETH.sol"; +import "./LegacySwapAdapter.sol"; + +contract TransformationAdapter is LegacySwapAdapter { + address private immutable WETH; + + constructor( + address _weth, + address _factory, + bytes32 _pairCodeHash, + address _conduitController, + address _bentobox + ) LegacySwapAdapter(_factory, _pairCodeHash, _conduitController, _bentobox) { + WETH = _weth; + } + + // transfers funds from msg.sender & performs swaps + function swapExactOut( + uint256 amountOut, + uint256 amountInMax, + address[] memory path, + address payable to, + TokenSource tokenSource, + bytes memory transferData, + bool unwrapNative + ) public payable { + _legacySwapExactOut( + amountOut, + amountInMax, + path, + unwrapNative ? address(this) : to, + tokenSource, + transferData + ); + + if (unwrapNative) { + IWETH(WETH).withdraw(amountOut); + if (to != address(this)) { + _transferEth(to, amountOut); + } + } + } + + // requires path[0] to have been sent to address(this) + function swapExactIn( + uint256 amountIn, + uint256 amountOutMin, + address[] memory path, + address payable to, + bool unwrapNative + ) public payable { + uint256 amountOut = _legacySwapExactIn( + amountIn, + amountOutMin, + path, + unwrapNative ? address(this) : to + ); + + if (unwrapNative) { + IWETH(WETH).withdraw(amountOut); + if (to != address(this)) { + _transferEth(to, amountOut); + } + } + + } + + // requires WETH to have been sent to address(this) + function unwrapNativeToken( + uint256 amount, + address payable to + ) public payable { + IWETH(WETH).withdraw(amount); + if (to != address(this)) { + _transferEth(to, amount); + } + } + + // requires ETH to have been sent to address(this) + function wrapNativeToken(uint256 amount) public payable { + IWETH(WETH).deposit{value: amount}(); + } +} \ No newline at end of file diff --git a/contracts/shoyu/interfaces/IAdapterRegistry.sol b/contracts/shoyu/interfaces/IAdapterRegistry.sol new file mode 100644 index 00000000..8eaa5c54 --- /dev/null +++ b/contracts/shoyu/interfaces/IAdapterRegistry.sol @@ -0,0 +1,21 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.8.11; + +import { Adapter } from "../lib/ShoyuStructs.sol"; + +interface IAdapterRegistry { + function setAdapterAddress( + uint256 id, + address adapterAddress + ) external; + + function setAdapterStatus( + uint256 id, + bool isActive + ) external; + + function addAdapter( + address adapterAddress, + bool isLibrary + ) external; +} \ No newline at end of file diff --git a/contracts/shoyu/interfaces/IShoyu.sol b/contracts/shoyu/interfaces/IShoyu.sol new file mode 100644 index 00000000..306c8f27 --- /dev/null +++ b/contracts/shoyu/interfaces/IShoyu.sol @@ -0,0 +1,33 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.8.13; + +interface IShoyu { + function cook( + uint8[] calldata adapterIds, + uint256[] calldata values, + bytes[] calldata datas + ) payable external; + + function approveERC20( + address token, + address operator, + uint256 amount + ) external; + + function retrieveETH(address to, uint256 amount) external; + + function retrieveERC20(address token, address to, uint256 amount) external; + + function retrieveERC721( + address token, + uint256[] calldata tokenIds, + address to + ) external; + + function retrieveERC1155( + address token, + uint256[] calldata tokenIds, + uint256[] calldata amounts, + address to + ) external; +} diff --git a/contracts/shoyu/lib/AdapterRegistry.sol b/contracts/shoyu/lib/AdapterRegistry.sol new file mode 100644 index 00000000..6bdd636a --- /dev/null +++ b/contracts/shoyu/lib/AdapterRegistry.sol @@ -0,0 +1,43 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.8.11; + +import "@openzeppelin/contracts/access/Ownable.sol"; +import "../interfaces/IAdapterRegistry.sol"; +import { Adapter } from "./ShoyuStructs.sol"; + +contract AdapterRegistry is IAdapterRegistry, Ownable { + Adapter[] public adapters; + + constructor( + uint256 length, + address[] memory adapterAddress, + bool[] memory isLibrary + ) { + for (uint256 i; i < length; ++i) { + adapters.push(Adapter(adapterAddress[i], isLibrary[i], true)); + } + } + + function setAdapterAddress( + uint256 id, + address adapterAddress + ) external onlyOwner { + Adapter storage adapter = adapters[id]; + adapter.adapterAddress = adapterAddress; + } + + function setAdapterStatus( + uint256 id, + bool isActive + ) external onlyOwner { + Adapter storage adapter = adapters[id]; + adapter.isActive = isActive; + } + + function addAdapter( + address adapterAddress, + bool isLibrary + ) external onlyOwner { + adapters.push(Adapter(adapterAddress, isLibrary, true)); + } +} \ No newline at end of file diff --git a/contracts/shoyu/lib/LibSushi.sol b/contracts/shoyu/lib/LibSushi.sol new file mode 100644 index 00000000..4c0b3616 --- /dev/null +++ b/contracts/shoyu/lib/LibSushi.sol @@ -0,0 +1,112 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.8.13; + +import "@sushiswap/core/contracts/uniswapv2/interfaces/IUniswapV2Pair.sol"; + +// returns sorted token addresses, used to handle return values from pairs sorted in this order +function sortTokens( + address tokenA, + address tokenB +) pure returns (address token0, address token1) { + require(tokenA != tokenB, 'UniswapV2Library: IDENTICAL_ADDRESSES'); + (token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA); + require(token0 != address(0), 'UniswapV2Library: ZERO_ADDRESS'); +} + +// calculates the CREATE2 address for a pair without making any external calls +function pairFor( + address factory, + address tokenA, + address tokenB, + bytes32 pairCodeHash +) pure returns (address pair) { + (address token0, address token1) = sortTokens(tokenA, tokenB); + pair = address(uint160(uint(keccak256(abi.encodePacked( + hex'ff', + factory, + keccak256(abi.encodePacked(token0, token1)), + pairCodeHash // init code hash + ))))); +} + +// fetches and sorts the reserves for a pair +function getReserves( + address factory, + address tokenA, + address tokenB, + bytes32 pairCodeHash +) view returns (uint reserveA, uint reserveB) { + (address token0,) = sortTokens(tokenA, tokenB); + (uint reserve0, uint reserve1,) = IUniswapV2Pair(pairFor(factory, tokenA, tokenB, pairCodeHash)).getReserves(); + (reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0); +} + +// given some amount of an asset and pair reserves, returns an equivalent amount of the other asset +function quote( + uint amountA, + uint reserveA, + uint reserveB +) pure returns (uint amountB) { + require(amountA > 0, 'UniswapV2Library: INSUFFICIENT_AMOUNT'); + require(reserveA > 0 && reserveB > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY'); + amountB = amountA * reserveB / reserveA; +} + +// given an input amount of an asset and pair reserves, returns the maximum output amount of the other asset +function getAmountOut( + uint amountIn, + uint reserveIn, + uint reserveOut +) pure returns (uint amountOut) { + require(amountIn > 0, 'UniswapV2Library: INSUFFICIENT_INPUT_AMOUNT'); + require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY'); + uint amountInWithFee = amountIn* 997; + uint numerator = amountInWithFee * reserveOut; + uint denominator = reserveIn * 1000 + amountInWithFee; + amountOut = numerator / denominator; +} + +// given an output amount of an asset and pair reserves, returns a required input amount of the other asset +function getAmountIn( + uint amountOut, + uint reserveIn, + uint reserveOut +) pure returns (uint amountIn) { + require(amountOut > 0, 'UniswapV2Library: INSUFFICIENT_OUTPUT_AMOUNT'); + require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY'); + uint numerator = reserveIn * amountOut * 1000; + uint denominator = (reserveOut - amountOut) * 997; + amountIn = numerator / denominator + 1; +} + +// performs chained getAmountOut calculations on any number of pairs +function getAmountsOut( + address factory, + uint amountIn, + address[] memory path, + bytes32 pairCodeHash +) view returns (uint[] memory amounts) { + require(path.length >= 2, 'UniswapV2Library: INVALID_PATH'); + amounts = new uint[](path.length); + amounts[0] = amountIn; + for (uint i; i < path.length - 1; i++) { + (uint reserveIn, uint reserveOut) = getReserves(factory, path[i], path[i + 1], pairCodeHash); + amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut); + } +} + +// performs chained getAmountIn calculations on any number of pairs +function getAmountsIn( + address factory, + uint amountOut, + address[] memory path, + bytes32 pairCodeHash +) view returns (uint[] memory amounts) { + require(path.length >= 2, 'UniswapV2Library: INVALID_PATH'); + amounts = new uint[](path.length); + amounts[amounts.length - 1] = amountOut; + for (uint i = path.length - 1; i > 0; i--) { + (uint reserveIn, uint reserveOut) = getReserves(factory, path[i - 1], path[i], pairCodeHash); + amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut); + } +} diff --git a/contracts/shoyu/lib/ShoyuEnums.sol b/contracts/shoyu/lib/ShoyuEnums.sol new file mode 100644 index 00000000..5f5c70cd --- /dev/null +++ b/contracts/shoyu/lib/ShoyuEnums.sol @@ -0,0 +1,8 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.8.13; + +enum TokenSource { + WALLET, + CONDUIT, + BENTO +} \ No newline at end of file diff --git a/contracts/shoyu/lib/ShoyuStructs.sol b/contracts/shoyu/lib/ShoyuStructs.sol new file mode 100644 index 00000000..f42fc0f3 --- /dev/null +++ b/contracts/shoyu/lib/ShoyuStructs.sol @@ -0,0 +1,25 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.8.7; + +struct OrderDetails { + uint256 value; + bytes data; +} + +struct SwapExactOutDetails { + address[] path; + uint256 amountInMax; + uint256 amountOut; +} + +struct SwapExactInDetails { + address[] path; + uint256 amountIn; + uint256 amountOutMin; +} + +struct Adapter { + address adapterAddress; + bool isLibrary; + bool isActive; +} \ No newline at end of file diff --git a/contracts/sushiswap/BentoBoxV1.sol b/contracts/sushiswap/BentoBoxV1.sol new file mode 100644 index 00000000..634bb34d --- /dev/null +++ b/contracts/sushiswap/BentoBoxV1.sol @@ -0,0 +1,1155 @@ +// SPDX-License-Identifier: UNLICENSED +// The BentoBox + +// ▄▄▄▄· ▄▄▄ . ▐ ▄ ▄▄▄▄▄ ▄▄▄▄· ▐▄• ▄ +// ▐█ ▀█▪▀▄.▀·█▌▐█•██ ▪ ▐█ ▀█▪▪ █▌█▌▪ +// ▐█▀▀█▄▐▀▀▪▄▐█▐▐▌ ▐█.▪ ▄█▀▄ ▐█▀▀█▄ ▄█▀▄ ·██· +// ██▄▪▐█▐█▄▄▌██▐█▌ ▐█▌·▐█▌.▐▌██▄▪▐█▐█▌.▐▌▪▐█·█▌ +// ·▀▀▀▀ ▀▀▀ ▀▀ █▪ ▀▀▀ ▀█▄▀▪·▀▀▀▀ ▀█▄▀▪•▀▀ ▀▀ + +// This contract stores funds, handles their transfers, supports flash loans and strategies. + +// Copyright (c) 2021 BoringCrypto - All rights reserved +// Twitter: @Boring_Crypto + +// Special thanks to Keno for all his hard work and support + +// Version 22-Mar-2021 + +pragma solidity 0.6.12; +pragma experimental ABIEncoderV2; + +// solhint-disable avoid-low-level-calls +// solhint-disable not-rely-on-time +// solhint-disable no-inline-assembly + +// File @boringcrypto/boring-solidity/contracts/interfaces/IERC20.sol@v1.2.0 +// License-Identifier: MIT + +interface IERC20 { + function totalSupply() external view returns (uint256); + + function balanceOf(address account) external view returns (uint256); + + function allowance(address owner, address spender) external view returns (uint256); + + function approve(address spender, uint256 amount) external returns (bool); + + event Transfer(address indexed from, address indexed to, uint256 value); + event Approval(address indexed owner, address indexed spender, uint256 value); + + /// @notice EIP 2612 + function permit( + address owner, + address spender, + uint256 value, + uint256 deadline, + uint8 v, + bytes32 r, + bytes32 s + ) external; + + function decimals() external view returns (uint256); +} + +// File contracts/interfaces/IFlashLoan.sol +// License-Identifier: MIT + +interface IFlashBorrower { + /// @notice The flashloan callback. `amount` + `fee` needs to repayed to msg.sender before this call returns. + /// @param sender The address of the invoker of this flashloan. + /// @param token The address of the token that is loaned. + /// @param amount of the `token` that is loaned. + /// @param fee The fee that needs to be paid on top for this loan. Needs to be the same as `token`. + /// @param data Additional data that was passed to the flashloan function. + function onFlashLoan( + address sender, + IERC20 token, + uint256 amount, + uint256 fee, + bytes calldata data + ) external; +} + +interface IBatchFlashBorrower { + /// @notice The callback for batched flashloans. Every amount + fee needs to repayed to msg.sender before this call returns. + /// @param sender The address of the invoker of this flashloan. + /// @param tokens Array of addresses for ERC-20 tokens that is loaned. + /// @param amounts A one-to-one map to `tokens` that is loaned. + /// @param fees A one-to-one map to `tokens` that needs to be paid on top for each loan. Needs to be the same token. + /// @param data Additional data that was passed to the flashloan function. + function onBatchFlashLoan( + address sender, + IERC20[] calldata tokens, + uint256[] calldata amounts, + uint256[] calldata fees, + bytes calldata data + ) external; +} + +// File contracts/interfaces/IWETH.sol +// License-Identifier: MIT + +interface IWETH { + function deposit() external payable; + + function withdraw(uint256) external; +} + +// File contracts/interfaces/IStrategy.sol +// License-Identifier: MIT + +interface IStrategy { + /// @notice Send the assets to the Strategy and call skim to invest them. + /// @param amount The amount of tokens to invest. + function skim(uint256 amount) external; + + /// @notice Harvest any profits made converted to the asset and pass them to the caller. + /// @param balance The amount of tokens the caller thinks it has invested. + /// @param sender The address of the initiator of this transaction. Can be used for reimbursements, etc. + /// @return amountAdded The delta (+profit or -loss) that occured in contrast to `balance`. + function harvest(uint256 balance, address sender) external returns (int256 amountAdded); + + /// @notice Withdraw assets. The returned amount can differ from the requested amount due to rounding. + /// @dev The `actualAmount` should be very close to the amount. + /// The difference should NOT be used to report a loss. That's what harvest is for. + /// @param amount The requested amount the caller wants to withdraw. + /// @return actualAmount The real amount that is withdrawn. + function withdraw(uint256 amount) external returns (uint256 actualAmount); + + /// @notice Withdraw all assets in the safest way possible. This shouldn't fail. + /// @param balance The amount of tokens the caller thinks it has invested. + /// @return amountAdded The delta (+profit or -loss) that occured in contrast to `balance`. + function exit(uint256 balance) external returns (int256 amountAdded); +} + +// File @boringcrypto/boring-solidity/contracts/libraries/BoringERC20.sol@v1.2.0 +// License-Identifier: MIT + +library BoringERC20 { + bytes4 private constant SIG_SYMBOL = 0x95d89b41; // symbol() + bytes4 private constant SIG_NAME = 0x06fdde03; // name() + bytes4 private constant SIG_DECIMALS = 0x313ce567; // decimals() + bytes4 private constant SIG_TRANSFER = 0xa9059cbb; // transfer(address,uint256) + bytes4 private constant SIG_TRANSFER_FROM = 0x23b872dd; // transferFrom(address,address,uint256) + + /// @notice Provides a safe ERC20.transfer version for different ERC-20 implementations. + /// Reverts on a failed transfer. + /// @param token The address of the ERC-20 token. + /// @param to Transfer tokens to. + /// @param amount The token amount. + function safeTransfer( + IERC20 token, + address to, + uint256 amount + ) internal { + (bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(SIG_TRANSFER, to, amount)); + require(success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: Transfer failed"); + } + + /// @notice Provides a safe ERC20.transferFrom version for different ERC-20 implementations. + /// Reverts on a failed transfer. + /// @param token The address of the ERC-20 token. + /// @param from Transfer tokens from. + /// @param to Transfer tokens to. + /// @param amount The token amount. + function safeTransferFrom( + IERC20 token, + address from, + address to, + uint256 amount + ) internal { + (bool success, bytes memory data) = address(token).call(abi.encodeWithSelector(SIG_TRANSFER_FROM, from, to, amount)); + require(success && (data.length == 0 || abi.decode(data, (bool))), "BoringERC20: TransferFrom failed"); + } +} + +// File @boringcrypto/boring-solidity/contracts/libraries/BoringMath.sol@v1.2.0 +// License-Identifier: MIT + +/// @notice A library for performing overflow-/underflow-safe math, +/// updated with awesomeness from of DappHub (https://github.com/dapphub/ds-math). +library BoringMath { + function add(uint256 a, uint256 b) internal pure returns (uint256 c) { + require((c = a + b) >= b, "BoringMath: Add Overflow"); + } + + function sub(uint256 a, uint256 b) internal pure returns (uint256 c) { + require((c = a - b) <= a, "BoringMath: Underflow"); + } + + function mul(uint256 a, uint256 b) internal pure returns (uint256 c) { + require(b == 0 || (c = a * b) / b == a, "BoringMath: Mul Overflow"); + } + + function to128(uint256 a) internal pure returns (uint128 c) { + require(a <= uint128(-1), "BoringMath: uint128 Overflow"); + c = uint128(a); + } + + function to64(uint256 a) internal pure returns (uint64 c) { + require(a <= uint64(-1), "BoringMath: uint64 Overflow"); + c = uint64(a); + } + + function to32(uint256 a) internal pure returns (uint32 c) { + require(a <= uint32(-1), "BoringMath: uint32 Overflow"); + c = uint32(a); + } +} + +/// @notice A library for performing overflow-/underflow-safe addition and subtraction on uint128. +library BoringMath128 { + function add(uint128 a, uint128 b) internal pure returns (uint128 c) { + require((c = a + b) >= b, "BoringMath: Add Overflow"); + } + + function sub(uint128 a, uint128 b) internal pure returns (uint128 c) { + require((c = a - b) <= a, "BoringMath: Underflow"); + } +} + +/// @notice A library for performing overflow-/underflow-safe addition and subtraction on uint64. +library BoringMath64 { + function add(uint64 a, uint64 b) internal pure returns (uint64 c) { + require((c = a + b) >= b, "BoringMath: Add Overflow"); + } + + function sub(uint64 a, uint64 b) internal pure returns (uint64 c) { + require((c = a - b) <= a, "BoringMath: Underflow"); + } +} + +/// @notice A library for performing overflow-/underflow-safe addition and subtraction on uint32. +library BoringMath32 { + function add(uint32 a, uint32 b) internal pure returns (uint32 c) { + require((c = a + b) >= b, "BoringMath: Add Overflow"); + } + + function sub(uint32 a, uint32 b) internal pure returns (uint32 c) { + require((c = a - b) <= a, "BoringMath: Underflow"); + } +} + +// File @boringcrypto/boring-solidity/contracts/libraries/BoringRebase.sol@v1.2.0 +// License-Identifier: MIT + +struct Rebase { + uint128 elastic; + uint128 base; +} + +/// @notice A rebasing library using overflow-/underflow-safe math. +library RebaseLibrary { + using BoringMath for uint256; + using BoringMath128 for uint128; + + /// @notice Calculates the base value in relationship to `elastic` and `total`. + function toBase( + Rebase memory total, + uint256 elastic, + bool roundUp + ) internal pure returns (uint256 base) { + if (total.elastic == 0) { + base = elastic; + } else { + base = elastic.mul(total.base) / total.elastic; + if (roundUp && base.mul(total.elastic) / total.base < elastic) { + base = base.add(1); + } + } + } + + /// @notice Calculates the elastic value in relationship to `base` and `total`. + function toElastic( + Rebase memory total, + uint256 base, + bool roundUp + ) internal pure returns (uint256 elastic) { + if (total.base == 0) { + elastic = base; + } else { + elastic = base.mul(total.elastic) / total.base; + if (roundUp && elastic.mul(total.base) / total.elastic < base) { + elastic = elastic.add(1); + } + } + } + + /// @notice Add `elastic` to `total` and doubles `total.base`. + /// @return (Rebase) The new total. + /// @return base in relationship to `elastic`. + function add( + Rebase memory total, + uint256 elastic, + bool roundUp + ) internal pure returns (Rebase memory, uint256 base) { + base = toBase(total, elastic, roundUp); + total.elastic = total.elastic.add(elastic.to128()); + total.base = total.base.add(base.to128()); + return (total, base); + } + + /// @notice Sub `base` from `total` and update `total.elastic`. + /// @return (Rebase) The new total. + /// @return elastic in relationship to `base`. + function sub( + Rebase memory total, + uint256 base, + bool roundUp + ) internal pure returns (Rebase memory, uint256 elastic) { + elastic = toElastic(total, base, roundUp); + total.elastic = total.elastic.sub(elastic.to128()); + total.base = total.base.sub(base.to128()); + return (total, elastic); + } + + /// @notice Add `elastic` and `base` to `total`. + function add( + Rebase memory total, + uint256 elastic, + uint256 base + ) internal pure returns (Rebase memory) { + total.elastic = total.elastic.add(elastic.to128()); + total.base = total.base.add(base.to128()); + return total; + } + + /// @notice Subtract `elastic` and `base` to `total`. + function sub( + Rebase memory total, + uint256 elastic, + uint256 base + ) internal pure returns (Rebase memory) { + total.elastic = total.elastic.sub(elastic.to128()); + total.base = total.base.sub(base.to128()); + return total; + } + + /// @notice Add `elastic` to `total` and update storage. + /// @return newElastic Returns updated `elastic`. + function addElastic(Rebase storage total, uint256 elastic) internal returns (uint256 newElastic) { + newElastic = total.elastic = total.elastic.add(elastic.to128()); + } + + /// @notice Subtract `elastic` from `total` and update storage. + /// @return newElastic Returns updated `elastic`. + function subElastic(Rebase storage total, uint256 elastic) internal returns (uint256 newElastic) { + newElastic = total.elastic = total.elastic.sub(elastic.to128()); + } +} + +// File @boringcrypto/boring-solidity/contracts/BoringOwnable.sol@v1.2.0 +// License-Identifier: MIT + +// Source: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/Ownable.sol + Claimable.sol +// Edited by BoringCrypto + +contract BoringOwnableData { + address public owner; + address public pendingOwner; +} + +contract BoringOwnable is BoringOwnableData { + event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); + + /// @notice `owner` defaults to msg.sender on construction. + constructor() public { + owner = msg.sender; + emit OwnershipTransferred(address(0), msg.sender); + } + + /// @notice Transfers ownership to `newOwner`. Either directly or claimable by the new pending owner. + /// Can only be invoked by the current `owner`. + /// @param newOwner Address of the new owner. + /// @param direct True if `newOwner` should be set immediately. False if `newOwner` needs to use `claimOwnership`. + /// @param renounce Allows the `newOwner` to be `address(0)` if `direct` and `renounce` is True. Has no effect otherwise. + function transferOwnership( + address newOwner, + bool direct, + bool renounce + ) public onlyOwner { + if (direct) { + // Checks + require(newOwner != address(0) || renounce, "Ownable: zero address"); + + // Effects + emit OwnershipTransferred(owner, newOwner); + owner = newOwner; + pendingOwner = address(0); + } else { + // Effects + pendingOwner = newOwner; + } + } + + /// @notice Needs to be called by `pendingOwner` to claim ownership. + function claimOwnership() public { + address _pendingOwner = pendingOwner; + + // Checks + require(msg.sender == _pendingOwner, "Ownable: caller != pending owner"); + + // Effects + emit OwnershipTransferred(owner, _pendingOwner); + owner = _pendingOwner; + pendingOwner = address(0); + } + + /// @notice Only allows the `owner` to execute the function. + modifier onlyOwner() { + require(msg.sender == owner, "Ownable: caller is not the owner"); + _; + } +} + +// File @boringcrypto/boring-solidity/contracts/interfaces/IMasterContract.sol@v1.2.0 +// License-Identifier: MIT + +interface IMasterContract { + /// @notice Init function that gets called from `BoringFactory.deploy`. + /// Also kown as the constructor for cloned contracts. + /// Any ETH send to `BoringFactory.deploy` ends up here. + /// @param data Can be abi encoded arguments or anything else. + function init(bytes calldata data) external payable; +} + +// File @boringcrypto/boring-solidity/contracts/BoringFactory.sol@v1.2.0 +// License-Identifier: MIT + +contract BoringFactory { + event LogDeploy(address indexed masterContract, bytes data, address indexed cloneAddress); + + /// @notice Mapping from clone contracts to their masterContract. + mapping(address => address) public masterContractOf; + + /// @notice Deploys a given master Contract as a clone. + /// Any ETH transferred with this call is forwarded to the new clone. + /// Emits `LogDeploy`. + /// @param masterContract The address of the contract to clone. + /// @param data Additional abi encoded calldata that is passed to the new clone via `IMasterContract.init`. + /// @param useCreate2 Creates the clone by using the CREATE2 opcode, in this case `data` will be used as salt. + /// @return cloneAddress Address of the created clone contract. + function deploy( + address masterContract, + bytes calldata data, + bool useCreate2 + ) public payable returns (address cloneAddress) { + require(masterContract != address(0), "BoringFactory: No masterContract"); + bytes20 targetBytes = bytes20(masterContract); // Takes the first 20 bytes of the masterContract's address + + if (useCreate2) { + // each masterContract has different code already. So clones are distinguished by their data only. + bytes32 salt = keccak256(data); + + // Creates clone, more info here: https://blog.openzeppelin.com/deep-dive-into-the-minimal-proxy-contract/ + assembly { + let clone := mload(0x40) + mstore(clone, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) + mstore(add(clone, 0x14), targetBytes) + mstore(add(clone, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000) + cloneAddress := create2(0, clone, 0x37, salt) + } + } else { + assembly { + let clone := mload(0x40) + mstore(clone, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000) + mstore(add(clone, 0x14), targetBytes) + mstore(add(clone, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000) + cloneAddress := create(0, clone, 0x37) + } + } + masterContractOf[cloneAddress] = masterContract; + + IMasterContract(cloneAddress).init{value: msg.value}(data); + + emit LogDeploy(masterContract, data, cloneAddress); + } +} + +// File contracts/MasterContractManager.sol +// License-Identifier: UNLICENSED + +contract MasterContractManager is BoringOwnable, BoringFactory { + event LogWhiteListMasterContract(address indexed masterContract, bool approved); + event LogSetMasterContractApproval(address indexed masterContract, address indexed user, bool approved); + event LogRegisterProtocol(address indexed protocol); + + /// @notice masterContract to user to approval state + mapping(address => mapping(address => bool)) public masterContractApproved; + /// @notice masterContract to whitelisted state for approval without signed message + mapping(address => bool) public whitelistedMasterContracts; + /// @notice user nonces for masterContract approvals + mapping(address => uint256) public nonces; + + bytes32 private constant DOMAIN_SEPARATOR_SIGNATURE_HASH = + keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)"); + // See https://eips.ethereum.org/EIPS/eip-191 + string private constant EIP191_PREFIX_FOR_EIP712_STRUCTURED_DATA = "\x19\x01"; + bytes32 private constant APPROVAL_SIGNATURE_HASH = + keccak256("SetMasterContractApproval(string warning,address user,address masterContract,bool approved,uint256 nonce)"); + + // solhint-disable-next-line var-name-mixedcase + bytes32 private immutable _DOMAIN_SEPARATOR; + // solhint-disable-next-line var-name-mixedcase + uint256 private immutable DOMAIN_SEPARATOR_CHAIN_ID; + + constructor() public { + uint256 chainId; + assembly { + chainId := chainid() + } + _DOMAIN_SEPARATOR = _calculateDomainSeparator(DOMAIN_SEPARATOR_CHAIN_ID = chainId); + } + + function _calculateDomainSeparator(uint256 chainId) private view returns (bytes32) { + return keccak256(abi.encode(DOMAIN_SEPARATOR_SIGNATURE_HASH, keccak256("BentoBox V1"), chainId, address(this))); + } + + // solhint-disable-next-line func-name-mixedcase + function DOMAIN_SEPARATOR() public view returns (bytes32) { + uint256 chainId; + assembly { + chainId := chainid() + } + return chainId == DOMAIN_SEPARATOR_CHAIN_ID ? _DOMAIN_SEPARATOR : _calculateDomainSeparator(chainId); + } + + /// @notice Other contracts need to register with this master contract so that users can approve them for the BentoBox. + function registerProtocol() public { + masterContractOf[msg.sender] = msg.sender; + emit LogRegisterProtocol(msg.sender); + } + + /// @notice Enables or disables a contract for approval without signed message. + function whitelistMasterContract(address masterContract, bool approved) public onlyOwner { + // Checks + require(masterContract != address(0), "MasterCMgr: Cannot approve 0"); + + // Effects + whitelistedMasterContracts[masterContract] = approved; + emit LogWhiteListMasterContract(masterContract, approved); + } + + /// @notice Approves or revokes a `masterContract` access to `user` funds. + /// @param user The address of the user that approves or revokes access. + /// @param masterContract The address who gains or loses access. + /// @param approved If True approves access. If False revokes access. + /// @param v Part of the signature. (See EIP-191) + /// @param r Part of the signature. (See EIP-191) + /// @param s Part of the signature. (See EIP-191) + // F4 - Check behaviour for all function arguments when wrong or extreme + // F4: Don't allow masterContract 0 to be approved. Unknown contracts will have a masterContract of 0. + // F4: User can't be 0 for signed approvals because the recoveredAddress will be 0 if ecrecover fails + function setMasterContractApproval( + address user, + address masterContract, + bool approved, + uint8 v, + bytes32 r, + bytes32 s + ) public { + // Checks + require(masterContract != address(0), "MasterCMgr: masterC not set"); // Important for security + + // If no signature is provided, the fallback is executed + if (r == 0 && s == 0 && v == 0) { + require(user == msg.sender, "MasterCMgr: user not sender"); + require(masterContractOf[user] == address(0), "MasterCMgr: user is clone"); + require(whitelistedMasterContracts[masterContract], "MasterCMgr: not whitelisted"); + } else { + // Important for security - any address without masterContract has address(0) as masterContract + // So approving address(0) would approve every address, leading to full loss of funds + // Also, ecrecover returns address(0) on failure. So we check this: + require(user != address(0), "MasterCMgr: User cannot be 0"); + + // C10 - Protect signatures against replay, use nonce and chainId (SWC-121) + // C10: nonce + chainId are used to prevent replays + // C11 - All signatures strictly EIP-712 (SWC-117 SWC-122) + // C11: signature is EIP-712 compliant + // C12 - abi.encodePacked can't contain variable length user input (SWC-133) + // C12: abi.encodePacked has fixed length parameters + bytes32 digest = keccak256( + abi.encodePacked( + EIP191_PREFIX_FOR_EIP712_STRUCTURED_DATA, + DOMAIN_SEPARATOR(), + keccak256( + abi.encode( + APPROVAL_SIGNATURE_HASH, + approved + ? keccak256("Give FULL access to funds in (and approved to) BentoBox?") + : keccak256("Revoke access to BentoBox?"), + user, + masterContract, + approved, + nonces[user]++ + ) + ) + ) + ); + address recoveredAddress = ecrecover(digest, v, r, s); + require(recoveredAddress == user, "MasterCMgr: Invalid Signature"); + } + + // Effects + masterContractApproved[masterContract][user] = approved; + emit LogSetMasterContractApproval(masterContract, user, approved); + } +} + +// File @boringcrypto/boring-solidity/contracts/BoringBatchable.sol@v1.2.0 +// License-Identifier: MIT + +contract BaseBoringBatchable { + /// @dev Helper function to extract a useful revert message from a failed call. + /// If the returned data is malformed or not correctly abi encoded then this call can fail itself. + function _getRevertMsg(bytes memory _returnData) internal pure returns (string memory) { + // If the _res length is less than 68, then the transaction failed silently (without a revert message) + if (_returnData.length < 68) return "Transaction reverted silently"; + + assembly { + // Slice the sighash. + _returnData := add(_returnData, 0x04) + } + return abi.decode(_returnData, (string)); // All that remains is the revert string + } + + /// @notice Allows batched call to self (this contract). + /// @param calls An array of inputs for each call. + /// @param revertOnFail If True then reverts after a failed call and stops doing further calls. + /// @return successes An array indicating the success of a call, mapped one-to-one to `calls`. + /// @return results An array with the returned data of each function call, mapped one-to-one to `calls`. + // F1: External is ok here because this is the batch function, adding it to a batch makes no sense + // F2: Calls in the batch may be payable, delegatecall operates in the same context, so each call in the batch has access to msg.value + // C3: The length of the loop is fully under user control, so can't be exploited + // C7: Delegatecall is only used on the same contract, so it's safe + function batch(bytes[] calldata calls, bool revertOnFail) external payable returns (bool[] memory successes, bytes[] memory results) { + successes = new bool[](calls.length); + results = new bytes[](calls.length); + for (uint256 i = 0; i < calls.length; i++) { + (bool success, bytes memory result) = address(this).delegatecall(calls[i]); + require(success || !revertOnFail, _getRevertMsg(result)); + successes[i] = success; + results[i] = result; + } + } +} + +contract BoringBatchable is BaseBoringBatchable { + /// @notice Call wrapper that performs `ERC20.permit` on `token`. + /// Lookup `IERC20.permit`. + // F6: Parameters can be used front-run the permit and the user's permit will fail (due to nonce or other revert) + // if part of a batch this could be used to grief once as the second call would not need the permit + function permitToken( + IERC20 token, + address from, + address to, + uint256 amount, + uint256 deadline, + uint8 v, + bytes32 r, + bytes32 s + ) public { + token.permit(from, to, amount, deadline, v, r, s); + } +} + +// File contracts/BentoBox.sol +// License-Identifier: UNLICENSED + +/// @title BentoBox +/// @author BoringCrypto, Keno +/// @notice The BentoBox is a vault for tokens. The stored tokens can be flash loaned and used in strategies. +/// Yield from this will go to the token depositors. +/// Rebasing tokens ARE NOT supported and WILL cause loss of funds. +/// Any funds transfered directly onto the BentoBox will be lost, use the deposit function instead. +contract BentoBoxV1 is MasterContractManager, BoringBatchable { + using BoringMath for uint256; + using BoringMath128 for uint128; + using BoringERC20 for IERC20; + using RebaseLibrary for Rebase; + + // ************** // + // *** EVENTS *** // + // ************** // + + event LogDeposit(IERC20 indexed token, address indexed from, address indexed to, uint256 amount, uint256 share); + event LogWithdraw(IERC20 indexed token, address indexed from, address indexed to, uint256 amount, uint256 share); + event LogTransfer(IERC20 indexed token, address indexed from, address indexed to, uint256 share); + + event LogFlashLoan(address indexed borrower, IERC20 indexed token, uint256 amount, uint256 feeAmount, address indexed receiver); + + event LogStrategyTargetPercentage(IERC20 indexed token, uint256 targetPercentage); + event LogStrategyQueued(IERC20 indexed token, IStrategy indexed strategy); + event LogStrategySet(IERC20 indexed token, IStrategy indexed strategy); + event LogStrategyInvest(IERC20 indexed token, uint256 amount); + event LogStrategyDivest(IERC20 indexed token, uint256 amount); + event LogStrategyProfit(IERC20 indexed token, uint256 amount); + event LogStrategyLoss(IERC20 indexed token, uint256 amount); + + // *************** // + // *** STRUCTS *** // + // *************** // + + struct StrategyData { + uint64 strategyStartDate; + uint64 targetPercentage; + uint128 balance; // the balance of the strategy that BentoBox thinks is in there + } + + // ******************************** // + // *** CONSTANTS AND IMMUTABLES *** // + // ******************************** // + + // V2 - Can they be private? + // V2: Private to save gas, to verify it's correct, check the constructor arguments + IERC20 private immutable wethToken; + + IERC20 private constant USE_ETHEREUM = IERC20(0); + uint256 private constant FLASH_LOAN_FEE = 50; // 0.05% + uint256 private constant FLASH_LOAN_FEE_PRECISION = 1e5; + uint256 private constant STRATEGY_DELAY = 0 weeks; + uint256 private constant MAX_TARGET_PERCENTAGE = 95; // 95% + uint256 private constant MINIMUM_SHARE_BALANCE = 1000; // To prevent the ratio going off + + // ***************** // + // *** VARIABLES *** // + // ***************** // + + // Balance per token per address/contract in shares + mapping(IERC20 => mapping(address => uint256)) public balanceOf; + + // Rebase from amount to share + mapping(IERC20 => Rebase) public totals; + + mapping(IERC20 => IStrategy) public strategy; + mapping(IERC20 => IStrategy) public pendingStrategy; + mapping(IERC20 => StrategyData) public strategyData; + + // ******************* // + // *** CONSTRUCTOR *** // + // ******************* // + + constructor(IERC20 wethToken_) public { + wethToken = wethToken_; + } + + // ***************** // + // *** MODIFIERS *** // + // ***************** // + + /// Modifier to check if the msg.sender is allowed to use funds belonging to the 'from' address. + /// If 'from' is msg.sender, it's allowed. + /// If 'from' is the BentoBox itself, it's allowed. Any ETH, token balances (above the known balances) or BentoBox balances + /// can be taken by anyone. + /// This is to enable skimming, not just for deposits, but also for withdrawals or transfers, enabling better composability. + /// If 'from' is a clone of a masterContract AND the 'from' address has approved that masterContract, it's allowed. + modifier allowed(address from) { + if (from != msg.sender && from != address(this)) { + // From is sender or you are skimming + address masterContract = masterContractOf[msg.sender]; + require(masterContract != address(0), "BentoBox: no masterContract"); + require(masterContractApproved[masterContract][from], "BentoBox: Transfer not approved"); + } + _; + } + + // ************************** // + // *** INTERNAL FUNCTIONS *** // + // ************************** // + + /// @dev Returns the total balance of `token` this contracts holds, + /// plus the total amount this contract thinks the strategy holds. + function _tokenBalanceOf(IERC20 token) internal view returns (uint256 amount) { + amount = token.balanceOf(address(this)).add(strategyData[token].balance); + } + + // ************************ // + // *** PUBLIC FUNCTIONS *** // + // ************************ // + + /// @dev Helper function to represent an `amount` of `token` in shares. + /// @param token The ERC-20 token. + /// @param amount The `token` amount. + /// @param roundUp If the result `share` should be rounded up. + /// @return share The token amount represented in shares. + function toShare( + IERC20 token, + uint256 amount, + bool roundUp + ) external view returns (uint256 share) { + share = totals[token].toBase(amount, roundUp); + } + + /// @dev Helper function represent shares back into the `token` amount. + /// @param token The ERC-20 token. + /// @param share The amount of shares. + /// @param roundUp If the result should be rounded up. + /// @return amount The share amount back into native representation. + function toAmount( + IERC20 token, + uint256 share, + bool roundUp + ) external view returns (uint256 amount) { + amount = totals[token].toElastic(share, roundUp); + } + + /// @notice Deposit an amount of `token` represented in either `amount` or `share`. + /// @param token_ The ERC-20 token to deposit. + /// @param from which account to pull the tokens. + /// @param to which account to push the tokens. + /// @param amount Token amount in native representation to deposit. + /// @param share Token amount represented in shares to deposit. Takes precedence over `amount`. + /// @return amountOut The amount deposited. + /// @return shareOut The deposited amount represented in shares. + function deposit( + IERC20 token_, + address from, + address to, + uint256 amount, + uint256 share + ) public payable allowed(from) returns (uint256 amountOut, uint256 shareOut) { + // Checks + require(to != address(0), "BentoBox: to not set"); // To avoid a bad UI from burning funds + + // Effects + IERC20 token = token_ == USE_ETHEREUM ? wethToken : token_; + Rebase memory total = totals[token]; + + // If a new token gets added, the tokenSupply call checks that this is a deployed contract. Needed for security. + require(total.elastic != 0 || token.totalSupply() > 0, "BentoBox: No tokens"); + if (share == 0) { + // value of the share may be lower than the amount due to rounding, that's ok + share = total.toBase(amount, false); + // Any deposit should lead to at least the minimum share balance, otherwise it's ignored (no amount taken) + if (total.base.add(share.to128()) < MINIMUM_SHARE_BALANCE) { + return (0, 0); + } + } else { + // amount may be lower than the value of share due to rounding, in that case, add 1 to amount (Always round up) + amount = total.toElastic(share, true); + } + + // In case of skimming, check that only the skimmable amount is taken. + // For ETH, the full balance is available, so no need to check. + // During flashloans the _tokenBalanceOf is lower than 'reality', so skimming deposits will mostly fail during a flashloan. + require( + from != address(this) || token_ == USE_ETHEREUM || amount <= _tokenBalanceOf(token).sub(total.elastic), + "BentoBox: Skim too much" + ); + + balanceOf[token][to] = balanceOf[token][to].add(share); + total.base = total.base.add(share.to128()); + total.elastic = total.elastic.add(amount.to128()); + totals[token] = total; + + // Interactions + // During the first deposit, we check that this token is 'real' + if (token_ == USE_ETHEREUM) { + // X2 - If there is an error, could it cause a DoS. Like balanceOf causing revert. (SWC-113) + // X2: If the WETH implementation is faulty or malicious, it will block adding ETH (but we know the WETH implementation) + IWETH(address(wethToken)).deposit{value: amount}(); + } else if (from != address(this)) { + // X2 - If there is an error, could it cause a DoS. Like balanceOf causing revert. (SWC-113) + // X2: If the token implementation is faulty or malicious, it may block adding tokens. Good. + token.safeTransferFrom(from, address(this), amount); + } + emit LogDeposit(token, from, to, amount, share); + amountOut = amount; + shareOut = share; + } + + /// @notice Withdraws an amount of `token` from a user account. + /// @param token_ The ERC-20 token to withdraw. + /// @param from which user to pull the tokens. + /// @param to which user to push the tokens. + /// @param amount of tokens. Either one of `amount` or `share` needs to be supplied. + /// @param share Like above, but `share` takes precedence over `amount`. + function withdraw( + IERC20 token_, + address from, + address to, + uint256 amount, + uint256 share + ) public allowed(from) returns (uint256 amountOut, uint256 shareOut) { + // Checks + require(to != address(0), "BentoBox: to not set"); // To avoid a bad UI from burning funds + + // Effects + IERC20 token = token_ == USE_ETHEREUM ? wethToken : token_; + Rebase memory total = totals[token]; + if (share == 0) { + // value of the share paid could be lower than the amount paid due to rounding, in that case, add a share (Always round up) + share = total.toBase(amount, true); + } else { + // amount may be lower than the value of share due to rounding, that's ok + amount = total.toElastic(share, false); + } + + balanceOf[token][from] = balanceOf[token][from].sub(share); + total.elastic = total.elastic.sub(amount.to128()); + total.base = total.base.sub(share.to128()); + // There have to be at least 1000 shares left to prevent reseting the share/amount ratio (unless it's fully emptied) + require(total.base >= MINIMUM_SHARE_BALANCE || total.base == 0, "BentoBox: cannot empty"); + totals[token] = total; + + // Interactions + if (token_ == USE_ETHEREUM) { + // X2, X3: A revert or big gas usage in the WETH contract could block withdrawals, but WETH9 is fine. + IWETH(address(wethToken)).withdraw(amount); + // X2, X3: A revert or big gas usage could block, however, the to address is under control of the caller. + (bool success, ) = to.call{value: amount}(""); + require(success, "BentoBox: ETH transfer failed"); + } else { + // X2, X3: A malicious token could block withdrawal of just THAT token. + // masterContracts may want to take care not to rely on withdraw always succeeding. + token.safeTransfer(to, amount); + } + emit LogWithdraw(token, from, to, amount, share); + amountOut = amount; + shareOut = share; + } + + /// @notice Transfer shares from a user account to another one. + /// @param token The ERC-20 token to transfer. + /// @param from which user to pull the tokens. + /// @param to which user to push the tokens. + /// @param share The amount of `token` in shares. + // Clones of master contracts can transfer from any account that has approved them + // F3 - Can it be combined with another similar function? + // F3: This isn't combined with transferMultiple for gas optimization + function transfer( + IERC20 token, + address from, + address to, + uint256 share + ) public allowed(from) { + // Checks + require(to != address(0), "BentoBox: to not set"); // To avoid a bad UI from burning funds + + // Effects + balanceOf[token][from] = balanceOf[token][from].sub(share); + balanceOf[token][to] = balanceOf[token][to].add(share); + + emit LogTransfer(token, from, to, share); + } + + /// @notice Transfer shares from a user account to multiple other ones. + /// @param token The ERC-20 token to transfer. + /// @param from which user to pull the tokens. + /// @param tos The receivers of the tokens. + /// @param shares The amount of `token` in shares for each receiver in `tos`. + // F3 - Can it be combined with another similar function? + // F3: This isn't combined with transfer for gas optimization + function transferMultiple( + IERC20 token, + address from, + address[] calldata tos, + uint256[] calldata shares + ) public allowed(from) { + // Checks + require(tos[0] != address(0), "BentoBox: to[0] not set"); // To avoid a bad UI from burning funds + + // Effects + uint256 totalAmount; + uint256 len = tos.length; + for (uint256 i = 0; i < len; i++) { + address to = tos[i]; + balanceOf[token][to] = balanceOf[token][to].add(shares[i]); + totalAmount = totalAmount.add(shares[i]); + emit LogTransfer(token, from, to, shares[i]); + } + balanceOf[token][from] = balanceOf[token][from].sub(totalAmount); + } + + /// @notice Flashloan ability. + /// @param borrower The address of the contract that implements and conforms to `IFlashBorrower` and handles the flashloan. + /// @param receiver Address of the token receiver. + /// @param token The address of the token to receive. + /// @param amount of the tokens to receive. + /// @param data The calldata to pass to the `borrower` contract. + // F5 - Checks-Effects-Interactions pattern followed? (SWC-107) + // F5: Not possible to follow this here, reentrancy has been reviewed + // F6 - Check for front-running possibilities, such as the approve function (SWC-114) + // F6: Slight grieving possible by withdrawing an amount before someone tries to flashloan close to the full amount. + function flashLoan( + IFlashBorrower borrower, + address receiver, + IERC20 token, + uint256 amount, + bytes calldata data + ) public { + uint256 fee = amount.mul(FLASH_LOAN_FEE) / FLASH_LOAN_FEE_PRECISION; + token.safeTransfer(receiver, amount); + + borrower.onFlashLoan(msg.sender, token, amount, fee, data); + + require(_tokenBalanceOf(token) >= totals[token].addElastic(fee.to128()), "BentoBox: Wrong amount"); + emit LogFlashLoan(address(borrower), token, amount, fee, receiver); + } + + /// @notice Support for batched flashloans. Useful to request multiple different `tokens` in a single transaction. + /// @param borrower The address of the contract that implements and conforms to `IBatchFlashBorrower` and handles the flashloan. + /// @param receivers An array of the token receivers. A one-to-one mapping with `tokens` and `amounts`. + /// @param tokens The addresses of the tokens. + /// @param amounts of the tokens for each receiver. + /// @param data The calldata to pass to the `borrower` contract. + // F5 - Checks-Effects-Interactions pattern followed? (SWC-107) + // F5: Not possible to follow this here, reentrancy has been reviewed + // F6 - Check for front-running possibilities, such as the approve function (SWC-114) + // F6: Slight grieving possible by withdrawing an amount before someone tries to flashloan close to the full amount. + function batchFlashLoan( + IBatchFlashBorrower borrower, + address[] calldata receivers, + IERC20[] calldata tokens, + uint256[] calldata amounts, + bytes calldata data + ) public { + uint256[] memory fees = new uint256[](tokens.length); + + uint256 len = tokens.length; + for (uint256 i = 0; i < len; i++) { + uint256 amount = amounts[i]; + fees[i] = amount.mul(FLASH_LOAN_FEE) / FLASH_LOAN_FEE_PRECISION; + + tokens[i].safeTransfer(receivers[i], amounts[i]); + } + + borrower.onBatchFlashLoan(msg.sender, tokens, amounts, fees, data); + + for (uint256 i = 0; i < len; i++) { + IERC20 token = tokens[i]; + require(_tokenBalanceOf(token) >= totals[token].addElastic(fees[i].to128()), "BentoBox: Wrong amount"); + emit LogFlashLoan(address(borrower), token, amounts[i], fees[i], receivers[i]); + } + } + + /// @notice Sets the target percentage of the strategy for `token`. + /// @dev Only the owner of this contract is allowed to change this. + /// @param token The address of the token that maps to a strategy to change. + /// @param targetPercentage_ The new target in percent. Must be lesser or equal to `MAX_TARGET_PERCENTAGE`. + function setStrategyTargetPercentage(IERC20 token, uint64 targetPercentage_) public onlyOwner { + // Checks + require(targetPercentage_ <= MAX_TARGET_PERCENTAGE, "StrategyManager: Target too high"); + + // Effects + strategyData[token].targetPercentage = targetPercentage_; + emit LogStrategyTargetPercentage(token, targetPercentage_); + } + + /// @notice Sets the contract address of a new strategy that conforms to `IStrategy` for `token`. + /// Must be called twice with the same arguments. + /// A new strategy becomes pending first and can be activated once `STRATEGY_DELAY` is over. + /// @dev Only the owner of this contract is allowed to change this. + /// @param token The address of the token that maps to a strategy to change. + /// @param newStrategy The address of the contract that conforms to `IStrategy`. + // F5 - Checks-Effects-Interactions pattern followed? (SWC-107) + // F5: Total amount is updated AFTER interaction. But strategy is under our control. + // C4 - Use block.timestamp only for long intervals (SWC-116) + // C4: block.timestamp is used for a period of 2 weeks, which is long enough + function setStrategy(IERC20 token, IStrategy newStrategy) public onlyOwner { + StrategyData memory data = strategyData[token]; + IStrategy pending = pendingStrategy[token]; + if (data.strategyStartDate == 0 || pending != newStrategy) { + pendingStrategy[token] = newStrategy; + // C1 - All math done through BoringMath (SWC-101) + // C1: Our sun will swallow the earth well before this overflows + data.strategyStartDate = (block.timestamp + STRATEGY_DELAY).to64(); + emit LogStrategyQueued(token, newStrategy); + } else { + require(data.strategyStartDate != 0 && block.timestamp >= data.strategyStartDate, "StrategyManager: Too early"); + if (address(strategy[token]) != address(0)) { + int256 balanceChange = strategy[token].exit(data.balance); + // Effects + if (balanceChange > 0) { + uint256 add = uint256(balanceChange); + totals[token].addElastic(add); + emit LogStrategyProfit(token, add); + } else if (balanceChange < 0) { + uint256 sub = uint256(-balanceChange); + totals[token].subElastic(sub); + emit LogStrategyLoss(token, sub); + } + + emit LogStrategyDivest(token, data.balance); + } + strategy[token] = pending; + data.strategyStartDate = 0; + data.balance = 0; + pendingStrategy[token] = IStrategy(0); + emit LogStrategySet(token, newStrategy); + } + strategyData[token] = data; + } + + /// @notice The actual process of yield farming. Executes the strategy of `token`. + /// Optionally does housekeeping if `balance` is true. + /// `maxChangeAmount` is relevant for skimming or withdrawing if `balance` is true. + /// @param token The address of the token for which a strategy is deployed. + /// @param balance True if housekeeping should be done. + /// @param maxChangeAmount The maximum amount for either pulling or pushing from/to the `IStrategy` contract. + // F5 - Checks-Effects-Interactions pattern followed? (SWC-107) + // F5: Total amount is updated AFTER interaction. But strategy is under our control. + // F5: Not followed to prevent reentrancy issues with flashloans and BentoBox skims? + function harvest( + IERC20 token, + bool balance, + uint256 maxChangeAmount + ) public { + StrategyData memory data = strategyData[token]; + IStrategy _strategy = strategy[token]; + int256 balanceChange = _strategy.harvest(data.balance, msg.sender); + if (balanceChange == 0 && !balance) { + return; + } + + uint256 totalElastic = totals[token].elastic; + + if (balanceChange > 0) { + uint256 add = uint256(balanceChange); + totalElastic = totalElastic.add(add); + totals[token].elastic = totalElastic.to128(); + emit LogStrategyProfit(token, add); + } else if (balanceChange < 0) { + // C1 - All math done through BoringMath (SWC-101) + // C1: balanceChange could overflow if it's max negative int128. + // But tokens with balances that large are not supported by the BentoBox. + uint256 sub = uint256(-balanceChange); + totalElastic = totalElastic.sub(sub); + totals[token].elastic = totalElastic.to128(); + data.balance = data.balance.sub(sub.to128()); + emit LogStrategyLoss(token, sub); + } + + if (balance) { + uint256 targetBalance = totalElastic.mul(data.targetPercentage) / 100; + // if data.balance == targetBalance there is nothing to update + if (data.balance < targetBalance) { + uint256 amountOut = targetBalance.sub(data.balance); + if (maxChangeAmount != 0 && amountOut > maxChangeAmount) { + amountOut = maxChangeAmount; + } + token.safeTransfer(address(_strategy), amountOut); + data.balance = data.balance.add(amountOut.to128()); + _strategy.skim(amountOut); + emit LogStrategyInvest(token, amountOut); + } else if (data.balance > targetBalance) { + uint256 amountIn = data.balance.sub(targetBalance.to128()); + if (maxChangeAmount != 0 && amountIn > maxChangeAmount) { + amountIn = maxChangeAmount; + } + + uint256 actualAmountIn = _strategy.withdraw(amountIn); + + data.balance = data.balance.sub(actualAmountIn.to128()); + emit LogStrategyDivest(token, actualAmountIn); + } + } + + strategyData[token] = data; + } + + // Contract should be able to receive ETH deposits to support deposit & skim + // solhint-disable-next-line no-empty-blocks + receive() external payable {} +} diff --git a/contracts/sushiswap/IBentoBoxMinimal.sol b/contracts/sushiswap/IBentoBoxMinimal.sol new file mode 100644 index 00000000..b2e1ed42 --- /dev/null +++ b/contracts/sushiswap/IBentoBoxMinimal.sol @@ -0,0 +1,86 @@ +// SPDX-License-Identifier: GPL-3.0-or-later + +pragma solidity >=0.8.11; + +/// @notice Minimal BentoBox vault interface. +/// @dev `token` is aliased as `address` from `IERC20` for simplicity. +interface IBentoBoxMinimal { + /// @notice Balance per ERC-20 token per account in shares. + function balanceOf(address, address) external view returns (uint256); + + /// @dev Helper function to represent an `amount` of `token` in shares. + /// @param token The ERC-20 token. + /// @param amount The `token` amount. + /// @param roundUp If the result `share` should be rounded up. + /// @return share The token amount represented in shares. + function toShare( + address token, + uint256 amount, + bool roundUp + ) external view returns (uint256 share); + + /// @dev Helper function to represent shares back into the `token` amount. + /// @param token The ERC-20 token. + /// @param share The amount of shares. + /// @param roundUp If the result should be rounded up. + /// @return amount The share amount back into native representation. + function toAmount( + address token, + uint256 share, + bool roundUp + ) external view returns (uint256 amount); + + /// @notice Registers this contract so that users can approve it for BentoBox. + function registerProtocol() external; + + /// @notice Deposit an amount of `token` represented in either `amount` or `share`. + /// @param token_ The ERC-20 token to deposit. + /// @param from which account to pull the tokens. + /// @param to which account to push the tokens. + /// @param amount Token amount in native representation to deposit. + /// @param share Token amount represented in shares to deposit. Takes precedence over `amount`. + /// @return amountOut The amount deposited. + /// @return shareOut The deposited amount represented in shares. + function deposit( + address token_, + address from, + address to, + uint256 amount, + uint256 share + ) external payable returns (uint256 amountOut, uint256 shareOut); + + /// @notice Withdraws an amount of `token` from a user account. + /// @param token_ The ERC-20 token to withdraw. + /// @param from which user to pull the tokens. + /// @param to which user to push the tokens. + /// @param amount of tokens. Either one of `amount` or `share` needs to be supplied. + /// @param share Like above, but `share` takes precedence over `amount`. + function withdraw( + address token_, + address from, + address to, + uint256 amount, + uint256 share + ) external returns (uint256 amountOut, uint256 shareOut); + + /// @notice Transfer shares from a user account to another one. + /// @param token The ERC-20 token to transfer. + /// @param from which user to pull the tokens. + /// @param to which user to push the tokens. + /// @param share The amount of `token` in shares. + function transfer( + address token, + address from, + address to, + uint256 share + ) external; + + function setMasterContractApproval( + address user, + address masterContract, + bool approved, + uint8 v, + bytes32 r, + bytes32 s + ) external; +} diff --git a/contracts/sushiswap/uniswapv2/UniswapV2Factory.sol b/contracts/sushiswap/uniswapv2/UniswapV2Factory.sol new file mode 100644 index 00000000..5bfb5dd7 --- /dev/null +++ b/contracts/sushiswap/uniswapv2/UniswapV2Factory.sol @@ -0,0 +1,4 @@ +// SPDX-License-Identifier: GPL-3.0 +pragma solidity =0.6.12; + +import "@sushiswap/core/contracts/uniswapv2/UniswapV2Factory.sol"; \ No newline at end of file diff --git a/contracts/sushiswap/uniswapv2/UniswapV2Router02.sol b/contracts/sushiswap/uniswapv2/UniswapV2Router02.sol new file mode 100644 index 00000000..1835fecb --- /dev/null +++ b/contracts/sushiswap/uniswapv2/UniswapV2Router02.sol @@ -0,0 +1,447 @@ +// SPDX-License-Identifier: GPL-3.0 + +pragma solidity =0.6.12; + +import './libraries/UniswapV2Library.sol'; +import '@sushiswap/core/contracts/uniswapv2/libraries/SafeMath.sol'; +import '@sushiswap/core/contracts/uniswapv2/libraries/TransferHelper.sol'; +import '@sushiswap/core/contracts/uniswapv2/interfaces/IUniswapV2Router02.sol'; +import '@sushiswap/core/contracts/uniswapv2/interfaces/IUniswapV2Factory.sol'; +import '@sushiswap/core/contracts/uniswapv2/interfaces/IERC20.sol'; +import '@sushiswap/core/contracts/uniswapv2/interfaces/IWETH.sol'; + +contract UniswapV2Router02 is IUniswapV2Router02 { + using SafeMathUniswap for uint; + + address public immutable override factory; + address public immutable override WETH; + + modifier ensure(uint deadline) { + require(deadline >= block.timestamp, 'UniswapV2Router: EXPIRED'); + _; + } + + constructor(address _factory, address _WETH) public { + factory = _factory; + WETH = _WETH; + } + + receive() external payable { + assert(msg.sender == WETH); // only accept ETH via fallback from the WETH contract + } + + // **** ADD LIQUIDITY **** + function _addLiquidity( + address tokenA, + address tokenB, + uint amountADesired, + uint amountBDesired, + uint amountAMin, + uint amountBMin + ) internal virtual returns (uint amountA, uint amountB) { + // create the pair if it doesn't exist yet + if (IUniswapV2Factory(factory).getPair(tokenA, tokenB) == address(0)) { + IUniswapV2Factory(factory).createPair(tokenA, tokenB); + } + (uint reserveA, uint reserveB) = UniswapV2Library.getReserves(factory, tokenA, tokenB); + if (reserveA == 0 && reserveB == 0) { + (amountA, amountB) = (amountADesired, amountBDesired); + } else { + uint amountBOptimal = UniswapV2Library.quote(amountADesired, reserveA, reserveB); + if (amountBOptimal <= amountBDesired) { + require(amountBOptimal >= amountBMin, 'UniswapV2Router: INSUFFICIENT_B_AMOUNT'); + (amountA, amountB) = (amountADesired, amountBOptimal); + } else { + uint amountAOptimal = UniswapV2Library.quote(amountBDesired, reserveB, reserveA); + assert(amountAOptimal <= amountADesired); + require(amountAOptimal >= amountAMin, 'UniswapV2Router: INSUFFICIENT_A_AMOUNT'); + (amountA, amountB) = (amountAOptimal, amountBDesired); + } + } + } + function addLiquidity( + address tokenA, + address tokenB, + uint amountADesired, + uint amountBDesired, + uint amountAMin, + uint amountBMin, + address to, + uint deadline + ) external virtual override ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) { + (amountA, amountB) = _addLiquidity(tokenA, tokenB, amountADesired, amountBDesired, amountAMin, amountBMin); + address pair = UniswapV2Library.pairFor(factory, tokenA, tokenB); + TransferHelper.safeTransferFrom(tokenA, msg.sender, pair, amountA); + TransferHelper.safeTransferFrom(tokenB, msg.sender, pair, amountB); + liquidity = IUniswapV2Pair(pair).mint(to); + } + function addLiquidityETH( + address token, + uint amountTokenDesired, + uint amountTokenMin, + uint amountETHMin, + address to, + uint deadline + ) external virtual override payable ensure(deadline) returns (uint amountToken, uint amountETH, uint liquidity) { + (amountToken, amountETH) = _addLiquidity( + token, + WETH, + amountTokenDesired, + msg.value, + amountTokenMin, + amountETHMin + ); + address pair = UniswapV2Library.pairFor(factory, token, WETH); + TransferHelper.safeTransferFrom(token, msg.sender, pair, amountToken); + IWETH(WETH).deposit{value: amountETH}(); + assert(IWETH(WETH).transfer(pair, amountETH)); + liquidity = IUniswapV2Pair(pair).mint(to); + // refund dust eth, if any + if (msg.value > amountETH) TransferHelper.safeTransferETH(msg.sender, msg.value - amountETH); + } + + // **** REMOVE LIQUIDITY **** + function removeLiquidity( + address tokenA, + address tokenB, + uint liquidity, + uint amountAMin, + uint amountBMin, + address to, + uint deadline + ) public virtual override ensure(deadline) returns (uint amountA, uint amountB) { + address pair = UniswapV2Library.pairFor(factory, tokenA, tokenB); + IUniswapV2Pair(pair).transferFrom(msg.sender, pair, liquidity); // send liquidity to pair + (uint amount0, uint amount1) = IUniswapV2Pair(pair).burn(to); + (address token0,) = UniswapV2Library.sortTokens(tokenA, tokenB); + (amountA, amountB) = tokenA == token0 ? (amount0, amount1) : (amount1, amount0); + require(amountA >= amountAMin, 'UniswapV2Router: INSUFFICIENT_A_AMOUNT'); + require(amountB >= amountBMin, 'UniswapV2Router: INSUFFICIENT_B_AMOUNT'); + } + function removeLiquidityETH( + address token, + uint liquidity, + uint amountTokenMin, + uint amountETHMin, + address to, + uint deadline + ) public virtual override ensure(deadline) returns (uint amountToken, uint amountETH) { + (amountToken, amountETH) = removeLiquidity( + token, + WETH, + liquidity, + amountTokenMin, + amountETHMin, + address(this), + deadline + ); + TransferHelper.safeTransfer(token, to, amountToken); + IWETH(WETH).withdraw(amountETH); + TransferHelper.safeTransferETH(to, amountETH); + } + function removeLiquidityWithPermit( + address tokenA, + address tokenB, + uint liquidity, + uint amountAMin, + uint amountBMin, + address to, + uint deadline, + bool approveMax, uint8 v, bytes32 r, bytes32 s + ) external virtual override returns (uint amountA, uint amountB) { + address pair = UniswapV2Library.pairFor(factory, tokenA, tokenB); + uint value = approveMax ? uint(-1) : liquidity; + IUniswapV2Pair(pair).permit(msg.sender, address(this), value, deadline, v, r, s); + (amountA, amountB) = removeLiquidity(tokenA, tokenB, liquidity, amountAMin, amountBMin, to, deadline); + } + function removeLiquidityETHWithPermit( + address token, + uint liquidity, + uint amountTokenMin, + uint amountETHMin, + address to, + uint deadline, + bool approveMax, uint8 v, bytes32 r, bytes32 s + ) external virtual override returns (uint amountToken, uint amountETH) { + address pair = UniswapV2Library.pairFor(factory, token, WETH); + uint value = approveMax ? uint(-1) : liquidity; + IUniswapV2Pair(pair).permit(msg.sender, address(this), value, deadline, v, r, s); + (amountToken, amountETH) = removeLiquidityETH(token, liquidity, amountTokenMin, amountETHMin, to, deadline); + } + + // **** REMOVE LIQUIDITY (supporting fee-on-transfer tokens) **** + function removeLiquidityETHSupportingFeeOnTransferTokens( + address token, + uint liquidity, + uint amountTokenMin, + uint amountETHMin, + address to, + uint deadline + ) public virtual override ensure(deadline) returns (uint amountETH) { + (, amountETH) = removeLiquidity( + token, + WETH, + liquidity, + amountTokenMin, + amountETHMin, + address(this), + deadline + ); + TransferHelper.safeTransfer(token, to, IERC20Uniswap(token).balanceOf(address(this))); + IWETH(WETH).withdraw(amountETH); + TransferHelper.safeTransferETH(to, amountETH); + } + function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens( + address token, + uint liquidity, + uint amountTokenMin, + uint amountETHMin, + address to, + uint deadline, + bool approveMax, uint8 v, bytes32 r, bytes32 s + ) external virtual override returns (uint amountETH) { + address pair = UniswapV2Library.pairFor(factory, token, WETH); + uint value = approveMax ? uint(-1) : liquidity; + IUniswapV2Pair(pair).permit(msg.sender, address(this), value, deadline, v, r, s); + amountETH = removeLiquidityETHSupportingFeeOnTransferTokens( + token, liquidity, amountTokenMin, amountETHMin, to, deadline + ); + } + + // **** SWAP **** + // requires the initial amount to have already been sent to the first pair + function _swap(uint[] memory amounts, address[] memory path, address _to) internal virtual { + for (uint i; i < path.length - 1; i++) { + (address input, address output) = (path[i], path[i + 1]); + (address token0,) = UniswapV2Library.sortTokens(input, output); + uint amountOut = amounts[i + 1]; + (uint amount0Out, uint amount1Out) = input == token0 ? (uint(0), amountOut) : (amountOut, uint(0)); + address to = i < path.length - 2 ? UniswapV2Library.pairFor(factory, output, path[i + 2]) : _to; + IUniswapV2Pair(UniswapV2Library.pairFor(factory, input, output)).swap( + amount0Out, amount1Out, to, new bytes(0) + ); + } + } + function swapExactTokensForTokens( + uint amountIn, + uint amountOutMin, + address[] calldata path, + address to, + uint deadline + ) external virtual override ensure(deadline) returns (uint[] memory amounts) { + amounts = UniswapV2Library.getAmountsOut(factory, amountIn, path); + require(amounts[amounts.length - 1] >= amountOutMin, 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT'); + TransferHelper.safeTransferFrom( + path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0] + ); + _swap(amounts, path, to); + } + function swapTokensForExactTokens( + uint amountOut, + uint amountInMax, + address[] calldata path, + address to, + uint deadline + ) external virtual override ensure(deadline) returns (uint[] memory amounts) { + amounts = UniswapV2Library.getAmountsIn(factory, amountOut, path); + require(amounts[0] <= amountInMax, 'UniswapV2Router: EXCESSIVE_INPUT_AMOUNT'); + TransferHelper.safeTransferFrom( + path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0] + ); + _swap(amounts, path, to); + } + function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) + external + virtual + override + payable + ensure(deadline) + returns (uint[] memory amounts) + { + require(path[0] == WETH, 'UniswapV2Router: INVALID_PATH'); + amounts = UniswapV2Library.getAmountsOut(factory, msg.value, path); + require(amounts[amounts.length - 1] >= amountOutMin, 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT'); + IWETH(WETH).deposit{value: amounts[0]}(); + assert(IWETH(WETH).transfer(UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0])); + _swap(amounts, path, to); + } + function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) + external + virtual + override + ensure(deadline) + returns (uint[] memory amounts) + { + require(path[path.length - 1] == WETH, 'UniswapV2Router: INVALID_PATH'); + amounts = UniswapV2Library.getAmountsIn(factory, amountOut, path); + require(amounts[0] <= amountInMax, 'UniswapV2Router: EXCESSIVE_INPUT_AMOUNT'); + TransferHelper.safeTransferFrom( + path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0] + ); + _swap(amounts, path, address(this)); + IWETH(WETH).withdraw(amounts[amounts.length - 1]); + TransferHelper.safeTransferETH(to, amounts[amounts.length - 1]); + } + function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) + external + virtual + override + ensure(deadline) + returns (uint[] memory amounts) + { + require(path[path.length - 1] == WETH, 'UniswapV2Router: INVALID_PATH'); + amounts = UniswapV2Library.getAmountsOut(factory, amountIn, path); + require(amounts[amounts.length - 1] >= amountOutMin, 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT'); + TransferHelper.safeTransferFrom( + path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0] + ); + _swap(amounts, path, address(this)); + IWETH(WETH).withdraw(amounts[amounts.length - 1]); + TransferHelper.safeTransferETH(to, amounts[amounts.length - 1]); + } + function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) + external + virtual + override + payable + ensure(deadline) + returns (uint[] memory amounts) + { + require(path[0] == WETH, 'UniswapV2Router: INVALID_PATH'); + amounts = UniswapV2Library.getAmountsIn(factory, amountOut, path); + require(amounts[0] <= msg.value, 'UniswapV2Router: EXCESSIVE_INPUT_AMOUNT'); + IWETH(WETH).deposit{value: amounts[0]}(); + assert(IWETH(WETH).transfer(UniswapV2Library.pairFor(factory, path[0], path[1]), amounts[0])); + _swap(amounts, path, to); + // refund dust eth, if any + if (msg.value > amounts[0]) TransferHelper.safeTransferETH(msg.sender, msg.value - amounts[0]); + } + + // **** SWAP (supporting fee-on-transfer tokens) **** + // requires the initial amount to have already been sent to the first pair + function _swapSupportingFeeOnTransferTokens(address[] memory path, address _to) internal virtual { + for (uint i; i < path.length - 1; i++) { + (address input, address output) = (path[i], path[i + 1]); + (address token0,) = UniswapV2Library.sortTokens(input, output); + IUniswapV2Pair pair = IUniswapV2Pair(UniswapV2Library.pairFor(factory, input, output)); + uint amountInput; + uint amountOutput; + { // scope to avoid stack too deep errors + (uint reserve0, uint reserve1,) = pair.getReserves(); + (uint reserveInput, uint reserveOutput) = input == token0 ? (reserve0, reserve1) : (reserve1, reserve0); + amountInput = IERC20Uniswap(input).balanceOf(address(pair)).sub(reserveInput); + amountOutput = UniswapV2Library.getAmountOut(amountInput, reserveInput, reserveOutput); + } + (uint amount0Out, uint amount1Out) = input == token0 ? (uint(0), amountOutput) : (amountOutput, uint(0)); + address to = i < path.length - 2 ? UniswapV2Library.pairFor(factory, output, path[i + 2]) : _to; + pair.swap(amount0Out, amount1Out, to, new bytes(0)); + } + } + function swapExactTokensForTokensSupportingFeeOnTransferTokens( + uint amountIn, + uint amountOutMin, + address[] calldata path, + address to, + uint deadline + ) external virtual override ensure(deadline) { + TransferHelper.safeTransferFrom( + path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amountIn + ); + uint balanceBefore = IERC20Uniswap(path[path.length - 1]).balanceOf(to); + _swapSupportingFeeOnTransferTokens(path, to); + require( + IERC20Uniswap(path[path.length - 1]).balanceOf(to).sub(balanceBefore) >= amountOutMin, + 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT' + ); + } + function swapExactETHForTokensSupportingFeeOnTransferTokens( + uint amountOutMin, + address[] calldata path, + address to, + uint deadline + ) + external + virtual + override + payable + ensure(deadline) + { + require(path[0] == WETH, 'UniswapV2Router: INVALID_PATH'); + uint amountIn = msg.value; + IWETH(WETH).deposit{value: amountIn}(); + assert(IWETH(WETH).transfer(UniswapV2Library.pairFor(factory, path[0], path[1]), amountIn)); + uint balanceBefore = IERC20Uniswap(path[path.length - 1]).balanceOf(to); + _swapSupportingFeeOnTransferTokens(path, to); + require( + IERC20Uniswap(path[path.length - 1]).balanceOf(to).sub(balanceBefore) >= amountOutMin, + 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT' + ); + } + function swapExactTokensForETHSupportingFeeOnTransferTokens( + uint amountIn, + uint amountOutMin, + address[] calldata path, + address to, + uint deadline + ) + external + virtual + override + ensure(deadline) + { + require(path[path.length - 1] == WETH, 'UniswapV2Router: INVALID_PATH'); + TransferHelper.safeTransferFrom( + path[0], msg.sender, UniswapV2Library.pairFor(factory, path[0], path[1]), amountIn + ); + _swapSupportingFeeOnTransferTokens(path, address(this)); + uint amountOut = IERC20Uniswap(WETH).balanceOf(address(this)); + require(amountOut >= amountOutMin, 'UniswapV2Router: INSUFFICIENT_OUTPUT_AMOUNT'); + IWETH(WETH).withdraw(amountOut); + TransferHelper.safeTransferETH(to, amountOut); + } + + // **** LIBRARY FUNCTIONS **** + function quote(uint amountA, uint reserveA, uint reserveB) public pure virtual override returns (uint amountB) { + return UniswapV2Library.quote(amountA, reserveA, reserveB); + } + + function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) + public + pure + virtual + override + returns (uint amountOut) + { + return UniswapV2Library.getAmountOut(amountIn, reserveIn, reserveOut); + } + + function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) + public + pure + virtual + override + returns (uint amountIn) + { + return UniswapV2Library.getAmountIn(amountOut, reserveIn, reserveOut); + } + + function getAmountsOut(uint amountIn, address[] memory path) + public + view + virtual + override + returns (uint[] memory amounts) + { + return UniswapV2Library.getAmountsOut(factory, amountIn, path); + } + + function getAmountsIn(uint amountOut, address[] memory path) + public + view + virtual + override + returns (uint[] memory amounts) + { + return UniswapV2Library.getAmountsIn(factory, amountOut, path); + } +} diff --git a/contracts/sushiswap/uniswapv2/libraries/UniswapV2Library.sol b/contracts/sushiswap/uniswapv2/libraries/UniswapV2Library.sol new file mode 100644 index 00000000..d886a1fe --- /dev/null +++ b/contracts/sushiswap/uniswapv2/libraries/UniswapV2Library.sol @@ -0,0 +1,86 @@ +// SPDX-License-Identifier: GPL-3.0 + +pragma solidity >=0.5.0; + +import '@sushiswap/core/contracts/uniswapv2/interfaces/IUniswapV2Pair.sol'; +import '@sushiswap/core/contracts/uniswapv2/interfaces/IUniswapV2Factory.sol'; + +import "@sushiswap/core/contracts/uniswapv2/libraries/SafeMath.sol"; + +library UniswapV2Library { + using SafeMathUniswap for uint; + + // returns sorted token addresses, used to handle return values from pairs sorted in this order + function sortTokens(address tokenA, address tokenB) internal pure returns (address token0, address token1) { + require(tokenA != tokenB, 'UniswapV2Library: IDENTICAL_ADDRESSES'); + (token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA); + require(token0 != address(0), 'UniswapV2Library: ZERO_ADDRESS'); + } + + // calculates the CREATE2 address for a pair without making any external calls + function pairFor(address factory, address tokenA, address tokenB) internal view returns (address pair) { + pair = IUniswapV2Factory(factory).getPair(tokenA,tokenB); + //(address token0, address token1) = sortTokens(tokenA, tokenB); + //pair = address(uint(keccak256(abi.encodePacked( + // hex'ff', + // factory, + // keccak256(abi.encodePacked(token0, token1)), + // hex'e18a34eb0e04b04f7a0ac29a6e80748dca96319b42c54d679cb821dca90c6303' // init code hash + // )))); + } + + // fetches and sorts the reserves for a pair + function getReserves(address factory, address tokenA, address tokenB) internal view returns (uint reserveA, uint reserveB) { + (address token0,) = sortTokens(tokenA, tokenB); + (uint reserve0, uint reserve1,) = IUniswapV2Pair(pairFor(factory, tokenA, tokenB)).getReserves(); + (reserveA, reserveB) = tokenA == token0 ? (reserve0, reserve1) : (reserve1, reserve0); + } + + // given some amount of an asset and pair reserves, returns an equivalent amount of the other asset + function quote(uint amountA, uint reserveA, uint reserveB) internal pure returns (uint amountB) { + require(amountA > 0, 'UniswapV2Library: INSUFFICIENT_AMOUNT'); + require(reserveA > 0 && reserveB > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY'); + amountB = amountA.mul(reserveB) / reserveA; + } + + // given an input amount of an asset and pair reserves, returns the maximum output amount of the other asset + function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) { + require(amountIn > 0, 'UniswapV2Library: INSUFFICIENT_INPUT_AMOUNT'); + require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY'); + uint amountInWithFee = amountIn.mul(997); + uint numerator = amountInWithFee.mul(reserveOut); + uint denominator = reserveIn.mul(1000).add(amountInWithFee); + amountOut = numerator / denominator; + } + + // given an output amount of an asset and pair reserves, returns a required input amount of the other asset + function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn) { + require(amountOut > 0, 'UniswapV2Library: INSUFFICIENT_OUTPUT_AMOUNT'); + require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY'); + uint numerator = reserveIn.mul(amountOut).mul(1000); + uint denominator = reserveOut.sub(amountOut).mul(997); + amountIn = (numerator / denominator).add(1); + } + + // performs chained getAmountOut calculations on any number of pairs + function getAmountsOut(address factory, uint amountIn, address[] memory path) internal view returns (uint[] memory amounts) { + require(path.length >= 2, 'UniswapV2Library: INVALID_PATH'); + amounts = new uint[](path.length); + amounts[0] = amountIn; + for (uint i; i < path.length - 1; i++) { + (uint reserveIn, uint reserveOut) = getReserves(factory, path[i], path[i + 1]); + amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut); + } + } + + // performs chained getAmountIn calculations on any number of pairs + function getAmountsIn(address factory, uint amountOut, address[] memory path) internal view returns (uint[] memory amounts) { + require(path.length >= 2, 'UniswapV2Library: INVALID_PATH'); + amounts = new uint[](path.length); + amounts[amounts.length - 1] = amountOut; + for (uint i = path.length - 1; i > 0; i--) { + (uint reserveIn, uint reserveOut) = getReserves(factory, path[i - 1], path[i]); + amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut); + } + } +} diff --git a/contracts/test/EIP1271Wallet.sol b/contracts/test/EIP1271Wallet.sol new file mode 100644 index 00000000..b0e5b50a --- /dev/null +++ b/contracts/test/EIP1271Wallet.sol @@ -0,0 +1,117 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.8.7; + +interface ERC20ApprovalInterface { + function approve(address, uint256) external returns (bool); +} + +interface NFTApprovalInterface { + function setApprovalForAll(address, bool) external; +} + +contract EIP1271Wallet { + bytes4 private constant _EIP_1271_MAGIC_VALUE = 0x1626ba7e; + + address public immutable owner; + + bool public showRevertMessage; + + mapping(bytes32 => bool) public digestApproved; + + bool public isValid; + + constructor(address _owner) { + owner = _owner; + showRevertMessage = true; + isValid = true; + } + + function setValid(bool valid) external { + isValid = valid; + } + + function revertWithMessage(bool showMessage) external { + showRevertMessage = showMessage; + } + + function registerDigest(bytes32 digest, bool approved) external { + digestApproved[digest] = approved; + } + + function approveERC20( + ERC20ApprovalInterface token, + address operator, + uint256 amount + ) external { + if (msg.sender != owner) { + revert("Only owner"); + } + + token.approve(operator, amount); + } + + function approveNFT(NFTApprovalInterface token, address operator) external { + if (msg.sender != owner) { + revert("Only owner"); + } + + token.setApprovalForAll(operator, true); + } + + function isValidSignature(bytes32 digest, bytes memory signature) + external + view + returns (bytes4) + { + if (digestApproved[digest]) { + return _EIP_1271_MAGIC_VALUE; + } + + // NOTE: this is obviously not secure, do not use outside of testing. + if (signature.length == 64) { + // All signatures of length 64 are OK as long as valid is true + return isValid ? _EIP_1271_MAGIC_VALUE : bytes4(0xffffffff); + } + + if (signature.length != 65) { + revert(); + } + + bytes32 r; + bytes32 s; + uint8 v; + + assembly { + r := mload(add(signature, 0x20)) + s := mload(add(signature, 0x40)) + v := byte(0, mload(add(signature, 0x60))) + } + + if ( + uint256(s) > + 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0 + ) { + revert(); + } + + if (v != 27 && v != 28) { + revert(); + } + + address signer = ecrecover(digest, v, r, s); + + if (signer == address(0)) { + revert(); + } + + if (signer != owner) { + if (showRevertMessage) { + revert("BAD SIGNER"); + } + + revert(); + } + + return isValid ? _EIP_1271_MAGIC_VALUE : bytes4(0xffffffff); + } +} diff --git a/contracts/test/Reenterer.sol b/contracts/test/Reenterer.sol new file mode 100644 index 00000000..18d7eda0 --- /dev/null +++ b/contracts/test/Reenterer.sol @@ -0,0 +1,35 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.8.7; + +contract Reenterer { + address public target; + uint256 public msgValue; + bytes public callData; + + event Reentered(bytes returnData); + + function prepare( + address targetToUse, + uint256 msgValueToUse, + bytes calldata callDataToUse + ) external { + target = targetToUse; + msgValue = msgValueToUse; + callData = callDataToUse; + } + + receive() external payable { + (bool success, bytes memory returnData) = target.call{ + value: msgValue + }(callData); + + if (!success) { + assembly { + returndatacopy(0, 0, returndatasize()) + revert(0, returndatasize()) + } + } + + emit Reentered(returnData); + } +} diff --git a/contracts/test/TestERC1155.sol b/contracts/test/TestERC1155.sol new file mode 100644 index 00000000..959dad79 --- /dev/null +++ b/contracts/test/TestERC1155.sol @@ -0,0 +1,20 @@ +//SPDX-License-Identifier: Unlicense +pragma solidity >=0.8.7; + +import "@rari-capital/solmate/src/tokens/ERC1155.sol"; + +// Used for minting test ERC1155s in our tests +contract TestERC1155 is ERC1155 { + function mint( + address to, + uint256 tokenId, + uint256 amount + ) public returns (bool) { + _mint(to, tokenId, amount, ""); + return true; + } + + function uri(uint256) public pure override returns (string memory) { + return "uri"; + } +} diff --git a/contracts/test/TestERC20.sol b/contracts/test/TestERC20.sol new file mode 100644 index 00000000..9113ecf6 --- /dev/null +++ b/contracts/test/TestERC20.sol @@ -0,0 +1,49 @@ +//SPDX-License-Identifier: Unlicense +pragma solidity >=0.8.7; + +import "@rari-capital/solmate/src/tokens/ERC20.sol"; + +// Used for minting test ERC20s in our tests +contract TestERC20 is ERC20("Test20", "TST20", 18) { + bool public blocked; + + bool public noReturnData; + + constructor() { + blocked = false; + noReturnData = false; + } + + function blockTransfer(bool blocking) external { + blocked = blocking; + } + + function setNoReturnData(bool noReturn) external { + noReturnData = noReturn; + } + + function mint(address to, uint256 amount) external returns (bool) { + _mint(to, amount); + return true; + } + + function transferFrom( + address from, + address to, + uint256 amount + ) public override returns (bool ok) { + if (blocked) { + return false; + } + + super.transferFrom(from, to, amount); + + if (noReturnData) { + assembly { + return(0, 0) + } + } + + ok = true; + } +} diff --git a/contracts/test/TestERC721.sol b/contracts/test/TestERC721.sol new file mode 100644 index 00000000..5e9e143e --- /dev/null +++ b/contracts/test/TestERC721.sol @@ -0,0 +1,16 @@ +//SPDX-License-Identifier: Unlicense +pragma solidity >=0.8.7; + +import "@rari-capital/solmate/src/tokens/ERC721.sol"; + +// Used for minting test ERC721s in our tests +contract TestERC721 is ERC721("Test721", "TST721") { + function mint(address to, uint256 tokenId) public returns (bool) { + _mint(to, tokenId); + return true; + } + + function tokenURI(uint256) public pure override returns (string memory) { + return "tokenURI"; + } +} diff --git a/contracts/test/TestWETH.sol b/contracts/test/TestWETH.sol new file mode 100644 index 00000000..bdeb342a --- /dev/null +++ b/contracts/test/TestWETH.sol @@ -0,0 +1,63 @@ +// SPDX-License-Identifier: MIT + +pragma solidity 0.6.12; + +contract TestWETH { + string public name = "Wrapped Ether"; + string public symbol = "WETH"; + uint8 public decimals = 18; + + event Approval(address indexed src, address indexed guy, uint256 wad); + event Transfer(address indexed src, address indexed dst, uint256 wad); + event Deposit(address indexed dst, uint256 wad); + event Withdrawal(address indexed src, uint256 wad); + + mapping(address => uint256) public balanceOf; + mapping(address => mapping(address => uint256)) public allowance; + + function deposit() public payable { + balanceOf[msg.sender] += msg.value; + emit Deposit(msg.sender, msg.value); + } + + function withdraw(uint256 wad) public { + require(balanceOf[msg.sender] >= wad, "WETH9: Error"); + balanceOf[msg.sender] -= wad; + msg.sender.transfer(wad); + emit Withdrawal(msg.sender, wad); + } + + function totalSupply() public view returns (uint256) { + return address(this).balance; + } + + function approve(address guy, uint256 wad) public returns (bool) { + allowance[msg.sender][guy] = wad; + emit Approval(msg.sender, guy, wad); + return true; + } + + function transfer(address dst, uint256 wad) public returns (bool) { + return transferFrom(msg.sender, dst, wad); + } + + function transferFrom( + address src, + address dst, + uint256 wad + ) public returns (bool) { + require(balanceOf[src] >= wad, "WETH9: Error"); + + if (src != msg.sender && allowance[src][msg.sender] != uint256(-1)) { + require(allowance[src][msg.sender] >= wad, "WETH9: Error"); + allowance[src][msg.sender] -= wad; + } + + balanceOf[src] -= wad; + balanceOf[dst] += wad; + + emit Transfer(src, dst, wad); + + return true; + } +} \ No newline at end of file diff --git a/contracts/test/TestZone.sol b/contracts/test/TestZone.sol new file mode 100644 index 00000000..780ae68a --- /dev/null +++ b/contracts/test/TestZone.sol @@ -0,0 +1,61 @@ +// SPDX-License-Identifier: MIT +pragma solidity >=0.8.7; + +import { ZoneInterface } from "seaport/contracts/interfaces/ZoneInterface.sol"; + +// prettier-ignore +import { + AdvancedOrder, + CriteriaResolver +} from "seaport/contracts/lib/ConsiderationStructs.sol"; + +contract TestZone is ZoneInterface { + function isValidOrder( + bytes32 orderHash, + address caller, + address offerer, + bytes32 zoneHash + ) external pure override returns (bytes4 validOrderMagicValue) { + orderHash; + caller; + offerer; + + if (zoneHash == bytes32(uint256(1))) { + revert("Revert on zone hash 1"); + } else if (zoneHash == bytes32(uint256(2))) { + assembly { + revert(0, 0) + } + } + + validOrderMagicValue = zoneHash != bytes32(uint256(3)) + ? ZoneInterface.isValidOrder.selector + : bytes4(0xffffffff); + } + + function isValidOrderIncludingExtraData( + bytes32 orderHash, + address caller, + AdvancedOrder calldata order, + bytes32[] calldata priorOrderHashes, + CriteriaResolver[] calldata criteriaResolvers + ) external pure override returns (bytes4 validOrderMagicValue) { + orderHash; + caller; + order; + priorOrderHashes; + criteriaResolvers; + + if (order.extraData.length == 4) { + revert("Revert on extraData length 4"); + } else if (order.extraData.length == 5) { + assembly { + revert(0, 0) + } + } + + validOrderMagicValue = order.parameters.zoneHash != bytes32(uint256(3)) + ? ZoneInterface.isValidOrder.selector + : bytes4(0xffffffff); + } +} diff --git a/deploy/Seaport.ts b/deploy/Seaport.ts new file mode 100644 index 00000000..a60fd894 --- /dev/null +++ b/deploy/Seaport.ts @@ -0,0 +1,45 @@ +import { DeployFunction } from "hardhat-deploy/types"; +import { HardhatRuntimeEnvironment } from "hardhat/types"; + +import { + CONDUIT_CONTROLLER_ADDRESS, + SEAPORT_ADDRESS, +} from "../constants/addresses"; + +const deployFunction: DeployFunction = async function ({ + ethers, + deployments, + getNamedAccounts, + getChainId, +}: HardhatRuntimeEnvironment) { + console.log("Running Seaport deploy script"); + + const { deploy } = deployments; + + const { deployer } = await getNamedAccounts(); + + const chainId = Number(await getChainId()); + + const conduitControllerAddress = CONDUIT_CONTROLLER_ADDRESS[chainId]; + + const seaport = await deploy("Seaport", { + from: deployer, + args: [conduitControllerAddress], + }); + + console.log("Deployed seaport contract at ", seaport.address); +}; + +export default deployFunction; + +deployFunction.tags = ["DeploySeaport"]; + +deployFunction.skip = ({ getChainId }) => + new Promise(async (resolve, reject) => { + try { + const chainId = Number(await getChainId()); + resolve(chainId in SEAPORT_ADDRESS); + } catch (error) { + reject(error); + } + }); diff --git a/deploy/Shoyu.ts b/deploy/Shoyu.ts new file mode 100644 index 00000000..fd926afe --- /dev/null +++ b/deploy/Shoyu.ts @@ -0,0 +1,102 @@ +import { + BENTOBOX_ADDRESS, + FACTORY_ADDRESS, + INIT_CODE_HASH, + WNATIVE_ADDRESS, +} from "@sushiswap/core-sdk"; +import { DeployFunction } from "hardhat-deploy/types"; +import { HardhatRuntimeEnvironment } from "hardhat/types"; +import { + CONDUIT_CONTROLLER_ADDRESS, + SEAPORT_ADDRESS, +} from "../constants/addresses"; + +const deployFunction: DeployFunction = async function ({ + ethers, + deployments, + getNamedAccounts, + getChainId, +}: HardhatRuntimeEnvironment) { + console.log("Running Shoyu deploy script"); + + const { deploy } = deployments; + + const { deployer } = await getNamedAccounts(); + + const chainId = Number(await getChainId()); + + let wethAddress, pairCodeHash, sushiswapFactory, seaport, bentobox; + + if (chainId === 31337) { + wethAddress = (await deployments.get("TestWETH")).address; + } else if (chainId in WNATIVE_ADDRESS) { + wethAddress = WNATIVE_ADDRESS[chainId]; + } else { + throw Error("No WNATIVE!"); + } + + if (chainId === 31337) { + sushiswapFactory = await ethers.getContract("UniswapV2Factory"); + } else if (chainId in FACTORY_ADDRESS) { + sushiswapFactory = await ethers.getContractAt( + "UniswapV2Factory", + FACTORY_ADDRESS[chainId] + ); + } else { + throw Error("No FACTORY!"); + } + + if (chainId === 31337) { + pairCodeHash = await sushiswapFactory.pairCodeHash(); + } else if (chainId in INIT_CODE_HASH) { + pairCodeHash = INIT_CODE_HASH[chainId]; + } else { + throw Error("No INIT_CODE_HASH!"); + } + + if (chainId === 31337) { + bentobox = await ethers.getContract("BentoBoxV1"); + } else if (chainId in BENTOBOX_ADDRESS) { + bentobox = await ethers.getContractAt( + "BentoBoxV1", + BENTOBOX_ADDRESS[chainId] + ); + } else { + throw Error("No BENTOBOX!"); + } + + if (chainId in SEAPORT_ADDRESS) { + seaport = await ethers.getContractAt("Seaport", SEAPORT_ADDRESS[chainId]); + } else { + seaport = await deployments.get("Seaport"); + } + + const transformationAdapter = await deploy("TransformationAdapter", { + from: deployer, + args: [ + wethAddress, + sushiswapFactory.address, + pairCodeHash, + CONDUIT_CONTROLLER_ADDRESS[chainId], + bentobox.address, + ], + }); + + const adapterRegistry = await deploy("AdapterRegistry", { + from: deployer, + args: [2, [transformationAdapter.address, seaport.address], [true, false]], + }); + + const shoyu = await deploy("Shoyu", { + from: deployer, + args: [adapterRegistry.address], + }); + + console.log("Shoyu deployed at address", shoyu.address); +}; + +export default deployFunction; + +deployFunction.dependencies = ["DeploySeaport", "DeploySushiswap"]; + +deployFunction.tags = ["DeployShoyu"]; diff --git a/deploy/Sushiswap.ts b/deploy/Sushiswap.ts new file mode 100644 index 00000000..8ecfb81a --- /dev/null +++ b/deploy/Sushiswap.ts @@ -0,0 +1,52 @@ +import { DeployFunction } from "hardhat-deploy/types"; +import { HardhatRuntimeEnvironment } from "hardhat/types"; + +const deployFunction: DeployFunction = async function ({ + ethers, + deployments, + getNamedAccounts, + getChainId, +}: HardhatRuntimeEnvironment) { + console.log("Running Sushiswap deploy script"); + + const { deploy } = deployments; + + const { deployer } = await getNamedAccounts(); + + const weth = await deployments.get("TestWETH"); + + const sushiswapFactory = await deploy("UniswapV2Factory", { + from: deployer, + args: [deployer], + }); + + const sushiswapRouter = await deploy("UniswapV2Router02", { + from: deployer, + args: [sushiswapFactory.address, weth.address], + }); + + const bentobox = await deploy("BentoBoxV1", { + from: deployer, + args: [weth.address], + }); + + console.log("Bentobox deployed at ", bentobox.address); + console.log("Sushiswap factory deployed at ", sushiswapFactory.address); + console.log("Sushiswap router deployed at ", sushiswapRouter.address); +}; + +export default deployFunction; + +deployFunction.dependencies = ["DeployTestWETH"]; + +deployFunction.tags = ["DeploySushiswap"]; + +deployFunction.skip = ({ getChainId }) => + new Promise(async (resolve, reject) => { + try { + const chainId = await getChainId(); + resolve(chainId !== "31337"); + } catch (error) { + reject(error); + } + }); diff --git a/deploy/TestWETH.ts b/deploy/TestWETH.ts new file mode 100644 index 00000000..f4b523e2 --- /dev/null +++ b/deploy/TestWETH.ts @@ -0,0 +1,37 @@ +import { DeployFunction } from "hardhat-deploy/types"; +import { HardhatRuntimeEnvironment } from "hardhat/types"; + +const deployFunction: DeployFunction = async function ({ + ethers, + deployments, + getNamedAccounts, +}: HardhatRuntimeEnvironment) { + console.log("Running TestWETH deploy script"); + + const { deploy } = deployments; + + const { deployer } = await getNamedAccounts(); + + await deploy("TestWETH", { + from: deployer, + deterministicDeployment: false, + }); + + const testWETH = await ethers.getContract("TestWETH"); + + console.log("TestWETH deployed at ", testWETH.address); +}; + +export default deployFunction; + +deployFunction.tags = ["DeployTestWETH"]; + +deployFunction.skip = ({ getChainId }) => + new Promise(async (resolve, reject) => { + try { + const chainId = await getChainId(); + resolve(chainId !== "31337"); + } catch (error) { + reject(error); + } + }); diff --git a/deployments/goerli/.chainId b/deployments/goerli/.chainId new file mode 100644 index 00000000..7813681f --- /dev/null +++ b/deployments/goerli/.chainId @@ -0,0 +1 @@ +5 \ No newline at end of file diff --git a/deployments/goerli/Seaport.json b/deployments/goerli/Seaport.json new file mode 100644 index 00000000..67538ce0 --- /dev/null +++ b/deployments/goerli/Seaport.json @@ -0,0 +1,3196 @@ +{ + "address": "0x94acb2F8cF5AE7BA3DF88f0A78ad884b55dc32eA", + "abi": [ + { + "inputs": [ + { + "internalType": "address", + "name": "conduitController", + "type": "address" + } + ], + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "inputs": [], + "name": "BadContractSignature", + "type": "error" + }, + { + "inputs": [], + "name": "BadFraction", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "address", + "name": "from", + "type": "address" + }, + { + "internalType": "address", + "name": "to", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "BadReturnValueFromERC20OnTransfer", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "uint8", + "name": "v", + "type": "uint8" + } + ], + "name": "BadSignatureV", + "type": "error" + }, + { + "inputs": [], + "name": "ConsiderationCriteriaResolverOutOfRange", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "orderIndex", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "considerationIndex", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "shortfallAmount", + "type": "uint256" + } + ], + "name": "ConsiderationNotMet", + "type": "error" + }, + { + "inputs": [], + "name": "CriteriaNotEnabledForItem", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "address", + "name": "from", + "type": "address" + }, + { + "internalType": "address", + "name": "to", + "type": "address" + }, + { + "internalType": "uint256[]", + "name": "identifiers", + "type": "uint256[]" + }, + { + "internalType": "uint256[]", + "name": "amounts", + "type": "uint256[]" + } + ], + "name": "ERC1155BatchTransferGenericFailure", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "EtherTransferGenericFailure", + "type": "error" + }, + { + "inputs": [], + "name": "InexactFraction", + "type": "error" + }, + { + "inputs": [], + "name": "InsufficientEtherSupplied", + "type": "error" + }, + { + "inputs": [], + "name": "Invalid1155BatchTransferEncoding", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidBasicOrderParameterEncoding", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "conduit", + "type": "address" + } + ], + "name": "InvalidCallToConduit", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidCanceller", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "conduitKey", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "conduit", + "type": "address" + } + ], + "name": "InvalidConduit", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidERC721TransferAmount", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidFulfillmentComponentData", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "uint256", + "name": "value", + "type": "uint256" + } + ], + "name": "InvalidMsgValue", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidNativeOfferItem", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidProof", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "orderHash", + "type": "bytes32" + } + ], + "name": "InvalidRestrictedOrder", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidSignature", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidSigner", + "type": "error" + }, + { + "inputs": [], + "name": "InvalidTime", + "type": "error" + }, + { + "inputs": [], + "name": "MismatchedFulfillmentOfferAndConsiderationComponents", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "enum Side", + "name": "side", + "type": "uint8" + } + ], + "name": "MissingFulfillmentComponentOnAggregation", + "type": "error" + }, + { + "inputs": [], + "name": "MissingItemAmount", + "type": "error" + }, + { + "inputs": [], + "name": "MissingOriginalConsiderationItems", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "account", + "type": "address" + } + ], + "name": "NoContract", + "type": "error" + }, + { + "inputs": [], + "name": "NoReentrantCalls", + "type": "error" + }, + { + "inputs": [], + "name": "NoSpecifiedOrdersAvailable", + "type": "error" + }, + { + "inputs": [], + "name": "OfferAndConsiderationRequiredOnFulfillment", + "type": "error" + }, + { + "inputs": [], + "name": "OfferCriteriaResolverOutOfRange", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "orderHash", + "type": "bytes32" + } + ], + "name": "OrderAlreadyFilled", + "type": "error" + }, + { + "inputs": [], + "name": "OrderCriteriaResolverOutOfRange", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "orderHash", + "type": "bytes32" + } + ], + "name": "OrderIsCancelled", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "orderHash", + "type": "bytes32" + } + ], + "name": "OrderPartiallyFilled", + "type": "error" + }, + { + "inputs": [], + "name": "PartialFillsNotEnabledForOrder", + "type": "error" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "address", + "name": "from", + "type": "address" + }, + { + "internalType": "address", + "name": "to", + "type": "address" + }, + { + "internalType": "uint256", + "name": "identifier", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "name": "TokenTransferGenericFailure", + "type": "error" + }, + { + "inputs": [], + "name": "UnresolvedConsiderationCriteria", + "type": "error" + }, + { + "inputs": [], + "name": "UnresolvedOfferCriteria", + "type": "error" + }, + { + "inputs": [], + "name": "UnusedItemParameters", + "type": "error" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "uint256", + "name": "newCounter", + "type": "uint256" + }, + { + "indexed": true, + "internalType": "address", + "name": "offerer", + "type": "address" + } + ], + "name": "CounterIncremented", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bytes32", + "name": "orderHash", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "offerer", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "zone", + "type": "address" + } + ], + "name": "OrderCancelled", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bytes32", + "name": "orderHash", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "offerer", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "zone", + "type": "address" + }, + { + "indexed": false, + "internalType": "address", + "name": "recipient", + "type": "address" + }, + { + "components": [ + { + "internalType": "enum ItemType", + "name": "itemType", + "type": "uint8" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "identifier", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + } + ], + "indexed": false, + "internalType": "struct SpentItem[]", + "name": "offer", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "enum ItemType", + "name": "itemType", + "type": "uint8" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "identifier", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "address payable", + "name": "recipient", + "type": "address" + } + ], + "indexed": false, + "internalType": "struct ReceivedItem[]", + "name": "consideration", + "type": "tuple[]" + } + ], + "name": "OrderFulfilled", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "internalType": "bytes32", + "name": "orderHash", + "type": "bytes32" + }, + { + "indexed": true, + "internalType": "address", + "name": "offerer", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "zone", + "type": "address" + } + ], + "name": "OrderValidated", + "type": "event" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "offerer", + "type": "address" + }, + { + "internalType": "address", + "name": "zone", + "type": "address" + }, + { + "components": [ + { + "internalType": "enum ItemType", + "name": "itemType", + "type": "uint8" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "identifierOrCriteria", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "startAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endAmount", + "type": "uint256" + } + ], + "internalType": "struct OfferItem[]", + "name": "offer", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "enum ItemType", + "name": "itemType", + "type": "uint8" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "identifierOrCriteria", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "startAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endAmount", + "type": "uint256" + }, + { + "internalType": "address payable", + "name": "recipient", + "type": "address" + } + ], + "internalType": "struct ConsiderationItem[]", + "name": "consideration", + "type": "tuple[]" + }, + { + "internalType": "enum OrderType", + "name": "orderType", + "type": "uint8" + }, + { + "internalType": "uint256", + "name": "startTime", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endTime", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "zoneHash", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "salt", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "conduitKey", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "counter", + "type": "uint256" + } + ], + "internalType": "struct OrderComponents[]", + "name": "orders", + "type": "tuple[]" + } + ], + "name": "cancel", + "outputs": [ + { + "internalType": "bool", + "name": "cancelled", + "type": "bool" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address", + "name": "offerer", + "type": "address" + }, + { + "internalType": "address", + "name": "zone", + "type": "address" + }, + { + "components": [ + { + "internalType": "enum ItemType", + "name": "itemType", + "type": "uint8" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "identifierOrCriteria", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "startAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endAmount", + "type": "uint256" + } + ], + "internalType": "struct OfferItem[]", + "name": "offer", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "enum ItemType", + "name": "itemType", + "type": "uint8" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "identifierOrCriteria", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "startAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endAmount", + "type": "uint256" + }, + { + "internalType": "address payable", + "name": "recipient", + "type": "address" + } + ], + "internalType": "struct ConsiderationItem[]", + "name": "consideration", + "type": "tuple[]" + }, + { + "internalType": "enum OrderType", + "name": "orderType", + "type": "uint8" + }, + { + "internalType": "uint256", + "name": "startTime", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endTime", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "zoneHash", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "salt", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "conduitKey", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "totalOriginalConsiderationItems", + "type": "uint256" + } + ], + "internalType": "struct OrderParameters", + "name": "parameters", + "type": "tuple" + }, + { + "internalType": "uint120", + "name": "numerator", + "type": "uint120" + }, + { + "internalType": "uint120", + "name": "denominator", + "type": "uint120" + }, + { + "internalType": "bytes", + "name": "signature", + "type": "bytes" + }, + { + "internalType": "bytes", + "name": "extraData", + "type": "bytes" + } + ], + "internalType": "struct AdvancedOrder", + "name": "advancedOrder", + "type": "tuple" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "orderIndex", + "type": "uint256" + }, + { + "internalType": "enum Side", + "name": "side", + "type": "uint8" + }, + { + "internalType": "uint256", + "name": "index", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "identifier", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "criteriaProof", + "type": "bytes32[]" + } + ], + "internalType": "struct CriteriaResolver[]", + "name": "criteriaResolvers", + "type": "tuple[]" + }, + { + "internalType": "bytes32", + "name": "fulfillerConduitKey", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "recipient", + "type": "address" + } + ], + "name": "fulfillAdvancedOrder", + "outputs": [ + { + "internalType": "bool", + "name": "fulfilled", + "type": "bool" + } + ], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address", + "name": "offerer", + "type": "address" + }, + { + "internalType": "address", + "name": "zone", + "type": "address" + }, + { + "components": [ + { + "internalType": "enum ItemType", + "name": "itemType", + "type": "uint8" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "identifierOrCriteria", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "startAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endAmount", + "type": "uint256" + } + ], + "internalType": "struct OfferItem[]", + "name": "offer", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "enum ItemType", + "name": "itemType", + "type": "uint8" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "identifierOrCriteria", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "startAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endAmount", + "type": "uint256" + }, + { + "internalType": "address payable", + "name": "recipient", + "type": "address" + } + ], + "internalType": "struct ConsiderationItem[]", + "name": "consideration", + "type": "tuple[]" + }, + { + "internalType": "enum OrderType", + "name": "orderType", + "type": "uint8" + }, + { + "internalType": "uint256", + "name": "startTime", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endTime", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "zoneHash", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "salt", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "conduitKey", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "totalOriginalConsiderationItems", + "type": "uint256" + } + ], + "internalType": "struct OrderParameters", + "name": "parameters", + "type": "tuple" + }, + { + "internalType": "uint120", + "name": "numerator", + "type": "uint120" + }, + { + "internalType": "uint120", + "name": "denominator", + "type": "uint120" + }, + { + "internalType": "bytes", + "name": "signature", + "type": "bytes" + }, + { + "internalType": "bytes", + "name": "extraData", + "type": "bytes" + } + ], + "internalType": "struct AdvancedOrder[]", + "name": "advancedOrders", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "orderIndex", + "type": "uint256" + }, + { + "internalType": "enum Side", + "name": "side", + "type": "uint8" + }, + { + "internalType": "uint256", + "name": "index", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "identifier", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "criteriaProof", + "type": "bytes32[]" + } + ], + "internalType": "struct CriteriaResolver[]", + "name": "criteriaResolvers", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "orderIndex", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "itemIndex", + "type": "uint256" + } + ], + "internalType": "struct FulfillmentComponent[][]", + "name": "offerFulfillments", + "type": "tuple[][]" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "orderIndex", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "itemIndex", + "type": "uint256" + } + ], + "internalType": "struct FulfillmentComponent[][]", + "name": "considerationFulfillments", + "type": "tuple[][]" + }, + { + "internalType": "bytes32", + "name": "fulfillerConduitKey", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "recipient", + "type": "address" + }, + { + "internalType": "uint256", + "name": "maximumFulfilled", + "type": "uint256" + } + ], + "name": "fulfillAvailableAdvancedOrders", + "outputs": [ + { + "internalType": "bool[]", + "name": "availableOrders", + "type": "bool[]" + }, + { + "components": [ + { + "components": [ + { + "internalType": "enum ItemType", + "name": "itemType", + "type": "uint8" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "identifier", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "address payable", + "name": "recipient", + "type": "address" + } + ], + "internalType": "struct ReceivedItem", + "name": "item", + "type": "tuple" + }, + { + "internalType": "address", + "name": "offerer", + "type": "address" + }, + { + "internalType": "bytes32", + "name": "conduitKey", + "type": "bytes32" + } + ], + "internalType": "struct Execution[]", + "name": "executions", + "type": "tuple[]" + } + ], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address", + "name": "offerer", + "type": "address" + }, + { + "internalType": "address", + "name": "zone", + "type": "address" + }, + { + "components": [ + { + "internalType": "enum ItemType", + "name": "itemType", + "type": "uint8" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "identifierOrCriteria", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "startAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endAmount", + "type": "uint256" + } + ], + "internalType": "struct OfferItem[]", + "name": "offer", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "enum ItemType", + "name": "itemType", + "type": "uint8" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "identifierOrCriteria", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "startAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endAmount", + "type": "uint256" + }, + { + "internalType": "address payable", + "name": "recipient", + "type": "address" + } + ], + "internalType": "struct ConsiderationItem[]", + "name": "consideration", + "type": "tuple[]" + }, + { + "internalType": "enum OrderType", + "name": "orderType", + "type": "uint8" + }, + { + "internalType": "uint256", + "name": "startTime", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endTime", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "zoneHash", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "salt", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "conduitKey", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "totalOriginalConsiderationItems", + "type": "uint256" + } + ], + "internalType": "struct OrderParameters", + "name": "parameters", + "type": "tuple" + }, + { + "internalType": "bytes", + "name": "signature", + "type": "bytes" + } + ], + "internalType": "struct Order[]", + "name": "orders", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "orderIndex", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "itemIndex", + "type": "uint256" + } + ], + "internalType": "struct FulfillmentComponent[][]", + "name": "offerFulfillments", + "type": "tuple[][]" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "orderIndex", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "itemIndex", + "type": "uint256" + } + ], + "internalType": "struct FulfillmentComponent[][]", + "name": "considerationFulfillments", + "type": "tuple[][]" + }, + { + "internalType": "bytes32", + "name": "fulfillerConduitKey", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "maximumFulfilled", + "type": "uint256" + } + ], + "name": "fulfillAvailableOrders", + "outputs": [ + { + "internalType": "bool[]", + "name": "availableOrders", + "type": "bool[]" + }, + { + "components": [ + { + "components": [ + { + "internalType": "enum ItemType", + "name": "itemType", + "type": "uint8" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "identifier", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "address payable", + "name": "recipient", + "type": "address" + } + ], + "internalType": "struct ReceivedItem", + "name": "item", + "type": "tuple" + }, + { + "internalType": "address", + "name": "offerer", + "type": "address" + }, + { + "internalType": "bytes32", + "name": "conduitKey", + "type": "bytes32" + } + ], + "internalType": "struct Execution[]", + "name": "executions", + "type": "tuple[]" + } + ], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "considerationToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "considerationIdentifier", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "considerationAmount", + "type": "uint256" + }, + { + "internalType": "address payable", + "name": "offerer", + "type": "address" + }, + { + "internalType": "address", + "name": "zone", + "type": "address" + }, + { + "internalType": "address", + "name": "offerToken", + "type": "address" + }, + { + "internalType": "uint256", + "name": "offerIdentifier", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "offerAmount", + "type": "uint256" + }, + { + "internalType": "enum BasicOrderType", + "name": "basicOrderType", + "type": "uint8" + }, + { + "internalType": "uint256", + "name": "startTime", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endTime", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "zoneHash", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "salt", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "offererConduitKey", + "type": "bytes32" + }, + { + "internalType": "bytes32", + "name": "fulfillerConduitKey", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "totalOriginalAdditionalRecipients", + "type": "uint256" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "address payable", + "name": "recipient", + "type": "address" + } + ], + "internalType": "struct AdditionalRecipient[]", + "name": "additionalRecipients", + "type": "tuple[]" + }, + { + "internalType": "bytes", + "name": "signature", + "type": "bytes" + } + ], + "internalType": "struct BasicOrderParameters", + "name": "parameters", + "type": "tuple" + } + ], + "name": "fulfillBasicOrder", + "outputs": [ + { + "internalType": "bool", + "name": "fulfilled", + "type": "bool" + } + ], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address", + "name": "offerer", + "type": "address" + }, + { + "internalType": "address", + "name": "zone", + "type": "address" + }, + { + "components": [ + { + "internalType": "enum ItemType", + "name": "itemType", + "type": "uint8" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "identifierOrCriteria", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "startAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endAmount", + "type": "uint256" + } + ], + "internalType": "struct OfferItem[]", + "name": "offer", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "enum ItemType", + "name": "itemType", + "type": "uint8" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "identifierOrCriteria", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "startAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endAmount", + "type": "uint256" + }, + { + "internalType": "address payable", + "name": "recipient", + "type": "address" + } + ], + "internalType": "struct ConsiderationItem[]", + "name": "consideration", + "type": "tuple[]" + }, + { + "internalType": "enum OrderType", + "name": "orderType", + "type": "uint8" + }, + { + "internalType": "uint256", + "name": "startTime", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endTime", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "zoneHash", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "salt", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "conduitKey", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "totalOriginalConsiderationItems", + "type": "uint256" + } + ], + "internalType": "struct OrderParameters", + "name": "parameters", + "type": "tuple" + }, + { + "internalType": "bytes", + "name": "signature", + "type": "bytes" + } + ], + "internalType": "struct Order", + "name": "order", + "type": "tuple" + }, + { + "internalType": "bytes32", + "name": "fulfillerConduitKey", + "type": "bytes32" + } + ], + "name": "fulfillOrder", + "outputs": [ + { + "internalType": "bool", + "name": "fulfilled", + "type": "bool" + } + ], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "address", + "name": "offerer", + "type": "address" + } + ], + "name": "getCounter", + "outputs": [ + { + "internalType": "uint256", + "name": "counter", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "internalType": "address", + "name": "offerer", + "type": "address" + }, + { + "internalType": "address", + "name": "zone", + "type": "address" + }, + { + "components": [ + { + "internalType": "enum ItemType", + "name": "itemType", + "type": "uint8" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "identifierOrCriteria", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "startAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endAmount", + "type": "uint256" + } + ], + "internalType": "struct OfferItem[]", + "name": "offer", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "enum ItemType", + "name": "itemType", + "type": "uint8" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "identifierOrCriteria", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "startAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endAmount", + "type": "uint256" + }, + { + "internalType": "address payable", + "name": "recipient", + "type": "address" + } + ], + "internalType": "struct ConsiderationItem[]", + "name": "consideration", + "type": "tuple[]" + }, + { + "internalType": "enum OrderType", + "name": "orderType", + "type": "uint8" + }, + { + "internalType": "uint256", + "name": "startTime", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endTime", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "zoneHash", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "salt", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "conduitKey", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "counter", + "type": "uint256" + } + ], + "internalType": "struct OrderComponents", + "name": "order", + "type": "tuple" + } + ], + "name": "getOrderHash", + "outputs": [ + { + "internalType": "bytes32", + "name": "orderHash", + "type": "bytes32" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "internalType": "bytes32", + "name": "orderHash", + "type": "bytes32" + } + ], + "name": "getOrderStatus", + "outputs": [ + { + "internalType": "bool", + "name": "isValidated", + "type": "bool" + }, + { + "internalType": "bool", + "name": "isCancelled", + "type": "bool" + }, + { + "internalType": "uint256", + "name": "totalFilled", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "totalSize", + "type": "uint256" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "incrementCounter", + "outputs": [ + { + "internalType": "uint256", + "name": "newCounter", + "type": "uint256" + } + ], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "information", + "outputs": [ + { + "internalType": "string", + "name": "version", + "type": "string" + }, + { + "internalType": "bytes32", + "name": "domainSeparator", + "type": "bytes32" + }, + { + "internalType": "address", + "name": "conduitController", + "type": "address" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address", + "name": "offerer", + "type": "address" + }, + { + "internalType": "address", + "name": "zone", + "type": "address" + }, + { + "components": [ + { + "internalType": "enum ItemType", + "name": "itemType", + "type": "uint8" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "identifierOrCriteria", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "startAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endAmount", + "type": "uint256" + } + ], + "internalType": "struct OfferItem[]", + "name": "offer", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "enum ItemType", + "name": "itemType", + "type": "uint8" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "identifierOrCriteria", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "startAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endAmount", + "type": "uint256" + }, + { + "internalType": "address payable", + "name": "recipient", + "type": "address" + } + ], + "internalType": "struct ConsiderationItem[]", + "name": "consideration", + "type": "tuple[]" + }, + { + "internalType": "enum OrderType", + "name": "orderType", + "type": "uint8" + }, + { + "internalType": "uint256", + "name": "startTime", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endTime", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "zoneHash", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "salt", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "conduitKey", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "totalOriginalConsiderationItems", + "type": "uint256" + } + ], + "internalType": "struct OrderParameters", + "name": "parameters", + "type": "tuple" + }, + { + "internalType": "uint120", + "name": "numerator", + "type": "uint120" + }, + { + "internalType": "uint120", + "name": "denominator", + "type": "uint120" + }, + { + "internalType": "bytes", + "name": "signature", + "type": "bytes" + }, + { + "internalType": "bytes", + "name": "extraData", + "type": "bytes" + } + ], + "internalType": "struct AdvancedOrder[]", + "name": "advancedOrders", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "orderIndex", + "type": "uint256" + }, + { + "internalType": "enum Side", + "name": "side", + "type": "uint8" + }, + { + "internalType": "uint256", + "name": "index", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "identifier", + "type": "uint256" + }, + { + "internalType": "bytes32[]", + "name": "criteriaProof", + "type": "bytes32[]" + } + ], + "internalType": "struct CriteriaResolver[]", + "name": "criteriaResolvers", + "type": "tuple[]" + }, + { + "components": [ + { + "components": [ + { + "internalType": "uint256", + "name": "orderIndex", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "itemIndex", + "type": "uint256" + } + ], + "internalType": "struct FulfillmentComponent[]", + "name": "offerComponents", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "orderIndex", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "itemIndex", + "type": "uint256" + } + ], + "internalType": "struct FulfillmentComponent[]", + "name": "considerationComponents", + "type": "tuple[]" + } + ], + "internalType": "struct Fulfillment[]", + "name": "fulfillments", + "type": "tuple[]" + } + ], + "name": "matchAdvancedOrders", + "outputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "enum ItemType", + "name": "itemType", + "type": "uint8" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "identifier", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "address payable", + "name": "recipient", + "type": "address" + } + ], + "internalType": "struct ReceivedItem", + "name": "item", + "type": "tuple" + }, + { + "internalType": "address", + "name": "offerer", + "type": "address" + }, + { + "internalType": "bytes32", + "name": "conduitKey", + "type": "bytes32" + } + ], + "internalType": "struct Execution[]", + "name": "executions", + "type": "tuple[]" + } + ], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address", + "name": "offerer", + "type": "address" + }, + { + "internalType": "address", + "name": "zone", + "type": "address" + }, + { + "components": [ + { + "internalType": "enum ItemType", + "name": "itemType", + "type": "uint8" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "identifierOrCriteria", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "startAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endAmount", + "type": "uint256" + } + ], + "internalType": "struct OfferItem[]", + "name": "offer", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "enum ItemType", + "name": "itemType", + "type": "uint8" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "identifierOrCriteria", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "startAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endAmount", + "type": "uint256" + }, + { + "internalType": "address payable", + "name": "recipient", + "type": "address" + } + ], + "internalType": "struct ConsiderationItem[]", + "name": "consideration", + "type": "tuple[]" + }, + { + "internalType": "enum OrderType", + "name": "orderType", + "type": "uint8" + }, + { + "internalType": "uint256", + "name": "startTime", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endTime", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "zoneHash", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "salt", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "conduitKey", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "totalOriginalConsiderationItems", + "type": "uint256" + } + ], + "internalType": "struct OrderParameters", + "name": "parameters", + "type": "tuple" + }, + { + "internalType": "bytes", + "name": "signature", + "type": "bytes" + } + ], + "internalType": "struct Order[]", + "name": "orders", + "type": "tuple[]" + }, + { + "components": [ + { + "components": [ + { + "internalType": "uint256", + "name": "orderIndex", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "itemIndex", + "type": "uint256" + } + ], + "internalType": "struct FulfillmentComponent[]", + "name": "offerComponents", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "uint256", + "name": "orderIndex", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "itemIndex", + "type": "uint256" + } + ], + "internalType": "struct FulfillmentComponent[]", + "name": "considerationComponents", + "type": "tuple[]" + } + ], + "internalType": "struct Fulfillment[]", + "name": "fulfillments", + "type": "tuple[]" + } + ], + "name": "matchOrders", + "outputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "enum ItemType", + "name": "itemType", + "type": "uint8" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "identifier", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "amount", + "type": "uint256" + }, + { + "internalType": "address payable", + "name": "recipient", + "type": "address" + } + ], + "internalType": "struct ReceivedItem", + "name": "item", + "type": "tuple" + }, + { + "internalType": "address", + "name": "offerer", + "type": "address" + }, + { + "internalType": "bytes32", + "name": "conduitKey", + "type": "bytes32" + } + ], + "internalType": "struct Execution[]", + "name": "executions", + "type": "tuple[]" + } + ], + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [], + "name": "name", + "outputs": [ + { + "internalType": "string", + "name": "contractName", + "type": "string" + } + ], + "stateMutability": "pure", + "type": "function" + }, + { + "inputs": [ + { + "components": [ + { + "components": [ + { + "internalType": "address", + "name": "offerer", + "type": "address" + }, + { + "internalType": "address", + "name": "zone", + "type": "address" + }, + { + "components": [ + { + "internalType": "enum ItemType", + "name": "itemType", + "type": "uint8" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "identifierOrCriteria", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "startAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endAmount", + "type": "uint256" + } + ], + "internalType": "struct OfferItem[]", + "name": "offer", + "type": "tuple[]" + }, + { + "components": [ + { + "internalType": "enum ItemType", + "name": "itemType", + "type": "uint8" + }, + { + "internalType": "address", + "name": "token", + "type": "address" + }, + { + "internalType": "uint256", + "name": "identifierOrCriteria", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "startAmount", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endAmount", + "type": "uint256" + }, + { + "internalType": "address payable", + "name": "recipient", + "type": "address" + } + ], + "internalType": "struct ConsiderationItem[]", + "name": "consideration", + "type": "tuple[]" + }, + { + "internalType": "enum OrderType", + "name": "orderType", + "type": "uint8" + }, + { + "internalType": "uint256", + "name": "startTime", + "type": "uint256" + }, + { + "internalType": "uint256", + "name": "endTime", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "zoneHash", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "salt", + "type": "uint256" + }, + { + "internalType": "bytes32", + "name": "conduitKey", + "type": "bytes32" + }, + { + "internalType": "uint256", + "name": "totalOriginalConsiderationItems", + "type": "uint256" + } + ], + "internalType": "struct OrderParameters", + "name": "parameters", + "type": "tuple" + }, + { + "internalType": "bytes", + "name": "signature", + "type": "bytes" + } + ], + "internalType": "struct Order[]", + "name": "orders", + "type": "tuple[]" + } + ], + "name": "validate", + "outputs": [ + { + "internalType": "bool", + "name": "validated", + "type": "bool" + } + ], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "transactionHash": "0x3ec461872ecd747bd8196a4dbdf2f6d0694c549d701055adb2a596907d0a307c", + "receipt": { + "to": null, + "from": "0x745E3182275791241eb92036a4A767664c456343", + "contractAddress": "0x94acb2F8cF5AE7BA3DF88f0A78ad884b55dc32eA", + "transactionIndex": 6, + "gasUsed": "5361287", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0x95c57c17eec51f90a8300eca062943b0da801dc00c57e94e92856783e2ebbb6b", + "transactionHash": "0x3ec461872ecd747bd8196a4dbdf2f6d0694c549d701055adb2a596907d0a307c", + "logs": [], + "blockNumber": 7105969, + "cumulativeGasUsed": "6007791", + "status": 1, + "byzantium": true + }, + "args": [ + "0x00000000006ce100a8b5ed8edf18ceef9e500697" + ], + "numDeployments": 1, + "solcInputHash": "88f2ecb91369a2a0c1e435d122c5f57a", + "metadata": "{\"compiler\":{\"version\":\"0.8.14+commit.80d49f37\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"conduitController\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"BadContractSignature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"BadFraction\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"BadReturnValueFromERC20OnTransfer\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"}],\"name\":\"BadSignatureV\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ConsiderationCriteriaResolverOutOfRange\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"orderIndex\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"considerationIndex\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"shortfallAmount\",\"type\":\"uint256\"}],\"name\":\"ConsiderationNotMet\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CriteriaNotEnabledForItem\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256[]\",\"name\":\"identifiers\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"name\":\"ERC1155BatchTransferGenericFailure\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"EtherTransferGenericFailure\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InexactFraction\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientEtherSupplied\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Invalid1155BatchTransferEncoding\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidBasicOrderParameterEncoding\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"conduit\",\"type\":\"address\"}],\"name\":\"InvalidCallToConduit\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidCanceller\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"conduitKey\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"conduit\",\"type\":\"address\"}],\"name\":\"InvalidConduit\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidERC721TransferAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidFulfillmentComponentData\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"InvalidMsgValue\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidNativeOfferItem\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidProof\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"}],\"name\":\"InvalidRestrictedOrder\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSignature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSigner\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTime\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MismatchedFulfillmentOfferAndConsiderationComponents\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"enum Side\",\"name\":\"side\",\"type\":\"uint8\"}],\"name\":\"MissingFulfillmentComponentOnAggregation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MissingItemAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MissingOriginalConsiderationItems\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"NoContract\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NoReentrantCalls\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NoSpecifiedOrdersAvailable\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OfferAndConsiderationRequiredOnFulfillment\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OfferCriteriaResolverOutOfRange\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"}],\"name\":\"OrderAlreadyFilled\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OrderCriteriaResolverOutOfRange\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"}],\"name\":\"OrderIsCancelled\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"}],\"name\":\"OrderPartiallyFilled\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"PartialFillsNotEnabledForOrder\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"identifier\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"TokenTransferGenericFailure\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UnresolvedConsiderationCriteria\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UnresolvedOfferCriteria\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UnusedItemParameters\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newCounter\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"offerer\",\"type\":\"address\"}],\"name\":\"CounterIncremented\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"offerer\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"zone\",\"type\":\"address\"}],\"name\":\"OrderCancelled\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"offerer\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"zone\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"enum ItemType\",\"name\":\"itemType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"identifier\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"indexed\":false,\"internalType\":\"struct SpentItem[]\",\"name\":\"offer\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"enum ItemType\",\"name\":\"itemType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"identifier\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address payable\",\"name\":\"recipient\",\"type\":\"address\"}],\"indexed\":false,\"internalType\":\"struct ReceivedItem[]\",\"name\":\"consideration\",\"type\":\"tuple[]\"}],\"name\":\"OrderFulfilled\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"offerer\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"zone\",\"type\":\"address\"}],\"name\":\"OrderValidated\",\"type\":\"event\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"offerer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"zone\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"enum ItemType\",\"name\":\"itemType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"identifierOrCriteria\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"startAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endAmount\",\"type\":\"uint256\"}],\"internalType\":\"struct OfferItem[]\",\"name\":\"offer\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"enum ItemType\",\"name\":\"itemType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"identifierOrCriteria\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"startAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endAmount\",\"type\":\"uint256\"},{\"internalType\":\"address payable\",\"name\":\"recipient\",\"type\":\"address\"}],\"internalType\":\"struct ConsiderationItem[]\",\"name\":\"consideration\",\"type\":\"tuple[]\"},{\"internalType\":\"enum OrderType\",\"name\":\"orderType\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"startTime\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endTime\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"zoneHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"conduitKey\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"counter\",\"type\":\"uint256\"}],\"internalType\":\"struct OrderComponents[]\",\"name\":\"orders\",\"type\":\"tuple[]\"}],\"name\":\"cancel\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"cancelled\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"offerer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"zone\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"enum ItemType\",\"name\":\"itemType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"identifierOrCriteria\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"startAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endAmount\",\"type\":\"uint256\"}],\"internalType\":\"struct OfferItem[]\",\"name\":\"offer\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"enum ItemType\",\"name\":\"itemType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"identifierOrCriteria\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"startAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endAmount\",\"type\":\"uint256\"},{\"internalType\":\"address payable\",\"name\":\"recipient\",\"type\":\"address\"}],\"internalType\":\"struct ConsiderationItem[]\",\"name\":\"consideration\",\"type\":\"tuple[]\"},{\"internalType\":\"enum OrderType\",\"name\":\"orderType\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"startTime\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endTime\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"zoneHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"conduitKey\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"totalOriginalConsiderationItems\",\"type\":\"uint256\"}],\"internalType\":\"struct OrderParameters\",\"name\":\"parameters\",\"type\":\"tuple\"},{\"internalType\":\"uint120\",\"name\":\"numerator\",\"type\":\"uint120\"},{\"internalType\":\"uint120\",\"name\":\"denominator\",\"type\":\"uint120\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"extraData\",\"type\":\"bytes\"}],\"internalType\":\"struct AdvancedOrder\",\"name\":\"advancedOrder\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"orderIndex\",\"type\":\"uint256\"},{\"internalType\":\"enum Side\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"identifier\",\"type\":\"uint256\"},{\"internalType\":\"bytes32[]\",\"name\":\"criteriaProof\",\"type\":\"bytes32[]\"}],\"internalType\":\"struct CriteriaResolver[]\",\"name\":\"criteriaResolvers\",\"type\":\"tuple[]\"},{\"internalType\":\"bytes32\",\"name\":\"fulfillerConduitKey\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"}],\"name\":\"fulfillAdvancedOrder\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"fulfilled\",\"type\":\"bool\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"offerer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"zone\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"enum ItemType\",\"name\":\"itemType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"identifierOrCriteria\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"startAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endAmount\",\"type\":\"uint256\"}],\"internalType\":\"struct OfferItem[]\",\"name\":\"offer\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"enum ItemType\",\"name\":\"itemType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"identifierOrCriteria\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"startAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endAmount\",\"type\":\"uint256\"},{\"internalType\":\"address payable\",\"name\":\"recipient\",\"type\":\"address\"}],\"internalType\":\"struct ConsiderationItem[]\",\"name\":\"consideration\",\"type\":\"tuple[]\"},{\"internalType\":\"enum OrderType\",\"name\":\"orderType\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"startTime\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endTime\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"zoneHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"conduitKey\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"totalOriginalConsiderationItems\",\"type\":\"uint256\"}],\"internalType\":\"struct OrderParameters\",\"name\":\"parameters\",\"type\":\"tuple\"},{\"internalType\":\"uint120\",\"name\":\"numerator\",\"type\":\"uint120\"},{\"internalType\":\"uint120\",\"name\":\"denominator\",\"type\":\"uint120\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"extraData\",\"type\":\"bytes\"}],\"internalType\":\"struct AdvancedOrder[]\",\"name\":\"advancedOrders\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"orderIndex\",\"type\":\"uint256\"},{\"internalType\":\"enum Side\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"identifier\",\"type\":\"uint256\"},{\"internalType\":\"bytes32[]\",\"name\":\"criteriaProof\",\"type\":\"bytes32[]\"}],\"internalType\":\"struct CriteriaResolver[]\",\"name\":\"criteriaResolvers\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"orderIndex\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"itemIndex\",\"type\":\"uint256\"}],\"internalType\":\"struct FulfillmentComponent[][]\",\"name\":\"offerFulfillments\",\"type\":\"tuple[][]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"orderIndex\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"itemIndex\",\"type\":\"uint256\"}],\"internalType\":\"struct FulfillmentComponent[][]\",\"name\":\"considerationFulfillments\",\"type\":\"tuple[][]\"},{\"internalType\":\"bytes32\",\"name\":\"fulfillerConduitKey\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"maximumFulfilled\",\"type\":\"uint256\"}],\"name\":\"fulfillAvailableAdvancedOrders\",\"outputs\":[{\"internalType\":\"bool[]\",\"name\":\"availableOrders\",\"type\":\"bool[]\"},{\"components\":[{\"components\":[{\"internalType\":\"enum ItemType\",\"name\":\"itemType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"identifier\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address payable\",\"name\":\"recipient\",\"type\":\"address\"}],\"internalType\":\"struct ReceivedItem\",\"name\":\"item\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"offerer\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"conduitKey\",\"type\":\"bytes32\"}],\"internalType\":\"struct Execution[]\",\"name\":\"executions\",\"type\":\"tuple[]\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"offerer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"zone\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"enum ItemType\",\"name\":\"itemType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"identifierOrCriteria\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"startAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endAmount\",\"type\":\"uint256\"}],\"internalType\":\"struct OfferItem[]\",\"name\":\"offer\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"enum ItemType\",\"name\":\"itemType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"identifierOrCriteria\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"startAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endAmount\",\"type\":\"uint256\"},{\"internalType\":\"address payable\",\"name\":\"recipient\",\"type\":\"address\"}],\"internalType\":\"struct ConsiderationItem[]\",\"name\":\"consideration\",\"type\":\"tuple[]\"},{\"internalType\":\"enum OrderType\",\"name\":\"orderType\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"startTime\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endTime\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"zoneHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"conduitKey\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"totalOriginalConsiderationItems\",\"type\":\"uint256\"}],\"internalType\":\"struct OrderParameters\",\"name\":\"parameters\",\"type\":\"tuple\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"struct Order[]\",\"name\":\"orders\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"orderIndex\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"itemIndex\",\"type\":\"uint256\"}],\"internalType\":\"struct FulfillmentComponent[][]\",\"name\":\"offerFulfillments\",\"type\":\"tuple[][]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"orderIndex\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"itemIndex\",\"type\":\"uint256\"}],\"internalType\":\"struct FulfillmentComponent[][]\",\"name\":\"considerationFulfillments\",\"type\":\"tuple[][]\"},{\"internalType\":\"bytes32\",\"name\":\"fulfillerConduitKey\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"maximumFulfilled\",\"type\":\"uint256\"}],\"name\":\"fulfillAvailableOrders\",\"outputs\":[{\"internalType\":\"bool[]\",\"name\":\"availableOrders\",\"type\":\"bool[]\"},{\"components\":[{\"components\":[{\"internalType\":\"enum ItemType\",\"name\":\"itemType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"identifier\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address payable\",\"name\":\"recipient\",\"type\":\"address\"}],\"internalType\":\"struct ReceivedItem\",\"name\":\"item\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"offerer\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"conduitKey\",\"type\":\"bytes32\"}],\"internalType\":\"struct Execution[]\",\"name\":\"executions\",\"type\":\"tuple[]\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"considerationToken\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"considerationIdentifier\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"considerationAmount\",\"type\":\"uint256\"},{\"internalType\":\"address payable\",\"name\":\"offerer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"zone\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"offerToken\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"offerIdentifier\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"offerAmount\",\"type\":\"uint256\"},{\"internalType\":\"enum BasicOrderType\",\"name\":\"basicOrderType\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"startTime\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endTime\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"zoneHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"offererConduitKey\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"fulfillerConduitKey\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"totalOriginalAdditionalRecipients\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address payable\",\"name\":\"recipient\",\"type\":\"address\"}],\"internalType\":\"struct AdditionalRecipient[]\",\"name\":\"additionalRecipients\",\"type\":\"tuple[]\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"struct BasicOrderParameters\",\"name\":\"parameters\",\"type\":\"tuple\"}],\"name\":\"fulfillBasicOrder\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"fulfilled\",\"type\":\"bool\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"offerer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"zone\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"enum ItemType\",\"name\":\"itemType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"identifierOrCriteria\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"startAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endAmount\",\"type\":\"uint256\"}],\"internalType\":\"struct OfferItem[]\",\"name\":\"offer\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"enum ItemType\",\"name\":\"itemType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"identifierOrCriteria\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"startAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endAmount\",\"type\":\"uint256\"},{\"internalType\":\"address payable\",\"name\":\"recipient\",\"type\":\"address\"}],\"internalType\":\"struct ConsiderationItem[]\",\"name\":\"consideration\",\"type\":\"tuple[]\"},{\"internalType\":\"enum OrderType\",\"name\":\"orderType\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"startTime\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endTime\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"zoneHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"conduitKey\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"totalOriginalConsiderationItems\",\"type\":\"uint256\"}],\"internalType\":\"struct OrderParameters\",\"name\":\"parameters\",\"type\":\"tuple\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"struct Order\",\"name\":\"order\",\"type\":\"tuple\"},{\"internalType\":\"bytes32\",\"name\":\"fulfillerConduitKey\",\"type\":\"bytes32\"}],\"name\":\"fulfillOrder\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"fulfilled\",\"type\":\"bool\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"offerer\",\"type\":\"address\"}],\"name\":\"getCounter\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"counter\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"offerer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"zone\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"enum ItemType\",\"name\":\"itemType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"identifierOrCriteria\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"startAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endAmount\",\"type\":\"uint256\"}],\"internalType\":\"struct OfferItem[]\",\"name\":\"offer\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"enum ItemType\",\"name\":\"itemType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"identifierOrCriteria\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"startAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endAmount\",\"type\":\"uint256\"},{\"internalType\":\"address payable\",\"name\":\"recipient\",\"type\":\"address\"}],\"internalType\":\"struct ConsiderationItem[]\",\"name\":\"consideration\",\"type\":\"tuple[]\"},{\"internalType\":\"enum OrderType\",\"name\":\"orderType\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"startTime\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endTime\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"zoneHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"conduitKey\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"counter\",\"type\":\"uint256\"}],\"internalType\":\"struct OrderComponents\",\"name\":\"order\",\"type\":\"tuple\"}],\"name\":\"getOrderHash\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"orderHash\",\"type\":\"bytes32\"}],\"name\":\"getOrderStatus\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"isValidated\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"isCancelled\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"totalFilled\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"totalSize\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"incrementCounter\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"newCounter\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"information\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"version\",\"type\":\"string\"},{\"internalType\":\"bytes32\",\"name\":\"domainSeparator\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"conduitController\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"offerer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"zone\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"enum ItemType\",\"name\":\"itemType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"identifierOrCriteria\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"startAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endAmount\",\"type\":\"uint256\"}],\"internalType\":\"struct OfferItem[]\",\"name\":\"offer\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"enum ItemType\",\"name\":\"itemType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"identifierOrCriteria\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"startAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endAmount\",\"type\":\"uint256\"},{\"internalType\":\"address payable\",\"name\":\"recipient\",\"type\":\"address\"}],\"internalType\":\"struct ConsiderationItem[]\",\"name\":\"consideration\",\"type\":\"tuple[]\"},{\"internalType\":\"enum OrderType\",\"name\":\"orderType\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"startTime\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endTime\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"zoneHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"conduitKey\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"totalOriginalConsiderationItems\",\"type\":\"uint256\"}],\"internalType\":\"struct OrderParameters\",\"name\":\"parameters\",\"type\":\"tuple\"},{\"internalType\":\"uint120\",\"name\":\"numerator\",\"type\":\"uint120\"},{\"internalType\":\"uint120\",\"name\":\"denominator\",\"type\":\"uint120\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"extraData\",\"type\":\"bytes\"}],\"internalType\":\"struct AdvancedOrder[]\",\"name\":\"advancedOrders\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"orderIndex\",\"type\":\"uint256\"},{\"internalType\":\"enum Side\",\"name\":\"side\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"identifier\",\"type\":\"uint256\"},{\"internalType\":\"bytes32[]\",\"name\":\"criteriaProof\",\"type\":\"bytes32[]\"}],\"internalType\":\"struct CriteriaResolver[]\",\"name\":\"criteriaResolvers\",\"type\":\"tuple[]\"},{\"components\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"orderIndex\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"itemIndex\",\"type\":\"uint256\"}],\"internalType\":\"struct FulfillmentComponent[]\",\"name\":\"offerComponents\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"orderIndex\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"itemIndex\",\"type\":\"uint256\"}],\"internalType\":\"struct FulfillmentComponent[]\",\"name\":\"considerationComponents\",\"type\":\"tuple[]\"}],\"internalType\":\"struct Fulfillment[]\",\"name\":\"fulfillments\",\"type\":\"tuple[]\"}],\"name\":\"matchAdvancedOrders\",\"outputs\":[{\"components\":[{\"components\":[{\"internalType\":\"enum ItemType\",\"name\":\"itemType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"identifier\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address payable\",\"name\":\"recipient\",\"type\":\"address\"}],\"internalType\":\"struct ReceivedItem\",\"name\":\"item\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"offerer\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"conduitKey\",\"type\":\"bytes32\"}],\"internalType\":\"struct Execution[]\",\"name\":\"executions\",\"type\":\"tuple[]\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"offerer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"zone\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"enum ItemType\",\"name\":\"itemType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"identifierOrCriteria\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"startAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endAmount\",\"type\":\"uint256\"}],\"internalType\":\"struct OfferItem[]\",\"name\":\"offer\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"enum ItemType\",\"name\":\"itemType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"identifierOrCriteria\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"startAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endAmount\",\"type\":\"uint256\"},{\"internalType\":\"address payable\",\"name\":\"recipient\",\"type\":\"address\"}],\"internalType\":\"struct ConsiderationItem[]\",\"name\":\"consideration\",\"type\":\"tuple[]\"},{\"internalType\":\"enum OrderType\",\"name\":\"orderType\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"startTime\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endTime\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"zoneHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"conduitKey\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"totalOriginalConsiderationItems\",\"type\":\"uint256\"}],\"internalType\":\"struct OrderParameters\",\"name\":\"parameters\",\"type\":\"tuple\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"struct Order[]\",\"name\":\"orders\",\"type\":\"tuple[]\"},{\"components\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"orderIndex\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"itemIndex\",\"type\":\"uint256\"}],\"internalType\":\"struct FulfillmentComponent[]\",\"name\":\"offerComponents\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"orderIndex\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"itemIndex\",\"type\":\"uint256\"}],\"internalType\":\"struct FulfillmentComponent[]\",\"name\":\"considerationComponents\",\"type\":\"tuple[]\"}],\"internalType\":\"struct Fulfillment[]\",\"name\":\"fulfillments\",\"type\":\"tuple[]\"}],\"name\":\"matchOrders\",\"outputs\":[{\"components\":[{\"components\":[{\"internalType\":\"enum ItemType\",\"name\":\"itemType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"identifier\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address payable\",\"name\":\"recipient\",\"type\":\"address\"}],\"internalType\":\"struct ReceivedItem\",\"name\":\"item\",\"type\":\"tuple\"},{\"internalType\":\"address\",\"name\":\"offerer\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"conduitKey\",\"type\":\"bytes32\"}],\"internalType\":\"struct Execution[]\",\"name\":\"executions\",\"type\":\"tuple[]\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"contractName\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"components\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"offerer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"zone\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"enum ItemType\",\"name\":\"itemType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"identifierOrCriteria\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"startAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endAmount\",\"type\":\"uint256\"}],\"internalType\":\"struct OfferItem[]\",\"name\":\"offer\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"enum ItemType\",\"name\":\"itemType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"identifierOrCriteria\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"startAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endAmount\",\"type\":\"uint256\"},{\"internalType\":\"address payable\",\"name\":\"recipient\",\"type\":\"address\"}],\"internalType\":\"struct ConsiderationItem[]\",\"name\":\"consideration\",\"type\":\"tuple[]\"},{\"internalType\":\"enum OrderType\",\"name\":\"orderType\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"startTime\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endTime\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"zoneHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"salt\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"conduitKey\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"totalOriginalConsiderationItems\",\"type\":\"uint256\"}],\"internalType\":\"struct OrderParameters\",\"name\":\"parameters\",\"type\":\"tuple\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"struct Order[]\",\"name\":\"orders\",\"type\":\"tuple[]\"}],\"name\":\"validate\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"validated\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"0age (0age.eth)\",\"custom:coauthor\":\"d1ll0n (d1ll0n.eth)transmissions11 (t11s.eth)\",\"custom:contributor\":\"Kartik (slokh.eth)LeFevre (lefevre.eth)Joseph Schiarizzi (CupOJoseph.eth)Aspyn Palatnick (stuckinaboot.eth)James Wenzel (emo.eth)Stephan Min (stephanm.eth)Ryan Ghods (ralxz.eth)hack3r-0m (hack3r-0m.eth)Diego Estevez (antidiego.eth)Chomtana (chomtana.eth)Saw-mon and Natalie (sawmonandnatalie.eth)0xBeans (0xBeans.eth)0x4non (punkdev.eth)Laurence E. Day (norsefire.eth)vectorized.eth (vectorized.eth)karmacoma (karmacoma.eth)horsefacts (horsefacts.eth)UncarvedBlock (uncarvedblock.eth)Zoraiz Mahmood (zorz.eth)William Poulin (wpoulin.eth)Rajiv Patel-O'Connor (rajivpoc.eth)tserg (tserg.eth)cygaar (cygaar.eth)Meta0xNull (meta0xnull.eth)gpersoon (gpersoon.eth)Matt Solomon (msolomon.eth)Weikang Song (weikangs.eth)zer0dot (zer0dot.eth)Mudit Gupta (mudit.eth)leonardoalt (leoalt.eth)cmichel (cmichel.eth)PraneshASP (pranesh.eth)JasperAlexander (jasperalexander.eth)Ellahi (ellahi.eth)zaz (1zaz1.eth)berndartmueller (berndartmueller.eth)dmfxyz (dmfxyz.eth)daltoncoder (dontkillrobots.eth)0xf4ce (0xf4ce.eth)phaze (phaze.eth)hrkrshnn (hrkrshnn.eth)axic (axic.eth)leastwood (leastwood.eth)0xsanson (sanson.eth)blockdev (blockd3v.eth)fiveoutofnine (fiveoutofnine.eth)shuklaayush (shuklaayush.eth)0xPatissierpcaversaccioDavid Eibercsanuragjainsach1r0twojoy0ori_dabushDaniel GelfandokkothejawaFlameHorizonvdrgdmitriiabokeh-ethasutorufosrfart(rfa)Riley Holterhusbig-tech-sux\",\"custom:version\":\"1.1\",\"errors\":{\"BadContractSignature()\":[{\"details\":\"Revert with an error when an EIP-1271 call to an account fails.\"}],\"BadFraction()\":[{\"details\":\"Revert with an error when supplying a fraction with a value of zero for the numerator or denominator, or one where the numerator exceeds the denominator.\"}],\"BadReturnValueFromERC20OnTransfer(address,address,address,uint256)\":[{\"details\":\"Revert with an error when an ERC20 token transfer returns a falsey value.\",\"params\":{\"amount\":\"The amount for the attempted ERC20 transfer.\",\"from\":\"The source of the attempted ERC20 transfer.\",\"to\":\"The recipient of the attempted ERC20 transfer.\",\"token\":\"The token for which the ERC20 transfer was attempted.\"}}],\"BadSignatureV(uint8)\":[{\"details\":\"Revert with an error when a signature that does not contain a v value of 27 or 28 has been supplied.\",\"params\":{\"v\":\"The invalid v value.\"}}],\"ConsiderationCriteriaResolverOutOfRange()\":[{\"details\":\"Revert with an error when providing a criteria resolver that refers to an order with a consideration item that has not been supplied.\"}],\"ConsiderationNotMet(uint256,uint256,uint256)\":[{\"details\":\"Revert with an error if a consideration amount has not been fully zeroed out after applying all fulfillments.\",\"params\":{\"considerationIndex\":\"The index of the consideration item on the order.\",\"orderIndex\":\"The index of the order with the consideration item with a shortfall.\",\"shortfallAmount\":\"The unfulfilled consideration amount.\"}}],\"CriteriaNotEnabledForItem()\":[{\"details\":\"Revert with an error when providing a criteria resolver that refers to an order with an item that does not expect a criteria to be resolved.\"}],\"ERC1155BatchTransferGenericFailure(address,address,address,uint256[],uint256[])\":[{\"details\":\"Revert with an error when a batch ERC1155 token transfer reverts.\",\"params\":{\"amounts\":\"The amounts for the attempted transfer.\",\"from\":\"The source of the attempted transfer.\",\"identifiers\":\"The identifiers for the attempted transfer.\",\"to\":\"The recipient of the attempted transfer.\",\"token\":\"The token for which the transfer was attempted.\"}}],\"EtherTransferGenericFailure(address,uint256)\":[{\"details\":\"Revert with an error when an ether transfer reverts.\"}],\"InexactFraction()\":[{\"details\":\"Revert with an error when attempting to apply a fraction as part of a partial fill that does not divide the target amount cleanly.\"}],\"InsufficientEtherSupplied()\":[{\"details\":\"Revert with an error when insufficient ether is supplied as part of msg.value when fulfilling orders.\"}],\"Invalid1155BatchTransferEncoding()\":[{\"details\":\"Revert with an error when attempting to execute an 1155 batch transfer using calldata not produced by default ABI encoding or with different lengths for ids and amounts arrays.\"}],\"InvalidBasicOrderParameterEncoding()\":[{\"details\":\"Revert with an error when attempting to fill a basic order using calldata not produced by default ABI encoding.\"}],\"InvalidCallToConduit(address)\":[{\"details\":\"Revert with an error when a call to a conduit fails with revert data that is too expensive to return.\"}],\"InvalidCanceller()\":[{\"details\":\"Revert with an error when attempting to cancel an order as a caller other than the indicated offerer or zone.\"}],\"InvalidConduit(bytes32,address)\":[{\"details\":\"Revert with an error when attempting to fill an order referencing an invalid conduit (i.e. one that has not been deployed).\"}],\"InvalidERC721TransferAmount()\":[{\"details\":\"Revert with an error when an ERC721 transfer with amount other than one is attempted.\"}],\"InvalidFulfillmentComponentData()\":[{\"details\":\"Revert with an error when an order or item index are out of range or a fulfillment component does not match the type, token, identifier, or conduit preference of the initial consideration item.\"}],\"InvalidMsgValue(uint256)\":[{\"details\":\"Revert with an error when a caller attempts to supply callvalue to a non-payable basic order route or does not supply any callvalue to a payable basic order route.\"}],\"InvalidNativeOfferItem()\":[{\"details\":\"Revert with an error when attempting to fulfill an order with an offer for ETH outside of matching orders.\"}],\"InvalidProof()\":[{\"details\":\"Revert with an error when providing a criteria resolver that contains an invalid proof with respect to the given item and chosen identifier.\"}],\"InvalidRestrictedOrder(bytes32)\":[{\"details\":\"Revert with an error when attempting to fill an order that specifies a restricted submitter as its order type when not submitted by either the offerer or the order's zone or approved as valid by the zone in question via a staticcall to `isValidOrder`.\",\"params\":{\"orderHash\":\"The order hash for the invalid restricted order.\"}}],\"InvalidSignature()\":[{\"details\":\"Revert with an error when a signer cannot be recovered from the supplied signature.\"}],\"InvalidSigner()\":[{\"details\":\"Revert with an error when the signer recovered by the supplied signature does not match the offerer or an allowed EIP-1271 signer as specified by the offerer in the event they are a contract.\"}],\"InvalidTime()\":[{\"details\":\"Revert with an error when attempting to fill an order outside the specified start time and end time.\"}],\"MismatchedFulfillmentOfferAndConsiderationComponents()\":[{\"details\":\"Revert with an error when the initial offer item named by a fulfillment component does not match the type, token, identifier, or conduit preference of the initial consideration item.\"}],\"MissingFulfillmentComponentOnAggregation(uint8)\":[{\"details\":\"Revert with an error when a fulfillment is provided that does not declare at least one component as part of a call to fulfill available orders.\"}],\"MissingItemAmount()\":[{\"details\":\"Revert with an error when attempting to fulfill an order where an item has an amount of zero.\"}],\"MissingOriginalConsiderationItems()\":[{\"details\":\"Revert with an error when an order is supplied for fulfillment with a consideration array that is shorter than the original array.\"}],\"NoContract(address)\":[{\"details\":\"Revert with an error when an account being called as an assumed contract does not have code and returns no data.\",\"params\":{\"account\":\"The account that should contain code.\"}}],\"NoReentrantCalls()\":[{\"details\":\"Revert with an error when a caller attempts to reenter a protected function.\"}],\"NoSpecifiedOrdersAvailable()\":[{\"details\":\"Revert with an error when attempting to fulfill any number of available orders when none are fulfillable.\"}],\"OfferAndConsiderationRequiredOnFulfillment()\":[{\"details\":\"Revert with an error when a fulfillment is provided that does not declare at least one offer component and at least one consideration component.\"}],\"OfferCriteriaResolverOutOfRange()\":[{\"details\":\"Revert with an error when providing a criteria resolver that refers to an order with an offer item that has not been supplied.\"}],\"OrderAlreadyFilled(bytes32)\":[{\"details\":\"Revert with an error when attempting to fill an order that has already been fully filled.\",\"params\":{\"orderHash\":\"The order hash on which a fill was attempted.\"}}],\"OrderCriteriaResolverOutOfRange()\":[{\"details\":\"Revert with an error when providing a criteria resolver that refers to an order that has not been supplied.\"}],\"OrderIsCancelled(bytes32)\":[{\"details\":\"Revert with an error when attempting to fill an order that has been cancelled.\",\"params\":{\"orderHash\":\"The hash of the cancelled order.\"}}],\"OrderPartiallyFilled(bytes32)\":[{\"details\":\"Revert with an error when attempting to fill a basic order that has been partially filled.\",\"params\":{\"orderHash\":\"The hash of the partially used order.\"}}],\"PartialFillsNotEnabledForOrder()\":[{\"details\":\"Revert with an error when a partial fill is attempted on an order that does not specify partial fill support in its order type.\"}],\"TokenTransferGenericFailure(address,address,address,uint256,uint256)\":[{\"details\":\"Revert with an error when an ERC20, ERC721, or ERC1155 token transfer reverts.\",\"params\":{\"amount\":\"The amount for the attempted transfer.\",\"from\":\"The source of the attempted transfer.\",\"identifier\":\"The identifier for the attempted transfer.\",\"to\":\"The recipient of the attempted transfer.\",\"token\":\"The token for which the transfer was attempted.\"}}],\"UnresolvedConsiderationCriteria()\":[{\"details\":\"Revert with an error if a consideration item still has unresolved criteria after applying all criteria resolvers.\"}],\"UnresolvedOfferCriteria()\":[{\"details\":\"Revert with an error if an offer item still has unresolved criteria after applying all criteria resolvers.\"}],\"UnusedItemParameters()\":[{\"details\":\"Revert with an error when attempting to fulfill an order where an item has unused parameters. This includes both the token and the identifier parameters for native transfers as well as the identifier parameter for ERC20 transfers. Note that the conduit does not perform this check, leaving it up to the calling channel to enforce when desired.\"}]},\"kind\":\"dev\",\"methods\":{\"cancel((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256)[])\":{\"params\":{\"orders\":\"The orders to cancel.\"},\"returns\":{\"cancelled\":\"A boolean indicating whether the supplied orders have been successfully cancelled.\"}},\"constructor\":{\"params\":{\"conduitController\":\"A contract that deploys conduits, or proxies that may optionally be used to transfer approved ERC20/721/1155 tokens.\"}},\"fulfillAdvancedOrder(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),uint120,uint120,bytes,bytes),(uint256,uint8,uint256,uint256,bytes32[])[],bytes32,address)\":{\"params\":{\"advancedOrder\":\"The order to fulfill along with the fraction of the order to attempt to fill. Note that both the offerer and the fulfiller must first approve this contract (or their conduit if indicated by the order) to transfer any relevant tokens on their behalf and that contracts must implement `onERC1155Received` to receive ERC1155 tokens as consideration. Also note that all offer and consideration components must have no remainder after multiplication of the respective amount with the supplied fraction for the partial fill to be considered valid.\",\"criteriaResolvers\":\"An array where each element contains a reference to a specific offer or consideration, a token identifier, and a proof that the supplied token identifier is contained in the merkle root held by the item in question's criteria element. Note that an empty criteria indicates that any (transferable) token identifier on the token in question is valid and that no associated proof needs to be supplied.\",\"fulfillerConduitKey\":\"A bytes32 value indicating what conduit, if any, to source the fulfiller's token approvals from. The zero hash signifies that no conduit should be used (and direct approvals set on Consideration).\",\"recipient\":\"The intended recipient for all received items, with `address(0)` indicating that the caller should receive the items.\"},\"returns\":{\"fulfilled\":\"A boolean indicating whether the order has been successfully fulfilled.\"}},\"fulfillAvailableAdvancedOrders(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),uint120,uint120,bytes,bytes)[],(uint256,uint8,uint256,uint256,bytes32[])[],(uint256,uint256)[][],(uint256,uint256)[][],bytes32,address,uint256)\":{\"params\":{\"advancedOrders\":\"The orders to fulfill along with the fraction of those orders to attempt to fill. Note that both the offerer and the fulfiller must first approve this contract (or their conduit if indicated by the order) to transfer any relevant tokens on their behalf and that contracts must implement `onERC1155Received` in order to receive ERC1155 tokens as consideration. Also note that all offer and consideration components must have no remainder after multiplication of the respective amount with the supplied fraction for an order's partial fill amount to be considered valid.\",\"considerationFulfillments\":\"An array of FulfillmentComponent arrays indicating which consideration items to attempt to aggregate when preparing executions.\",\"criteriaResolvers\":\"An array where each element contains a reference to a specific offer or consideration, a token identifier, and a proof that the supplied token identifier is contained in the merkle root held by the item in question's criteria element. Note that an empty criteria indicates that any (transferable) token identifier on the token in question is valid and that no associated proof needs to be supplied.\",\"fulfillerConduitKey\":\"A bytes32 value indicating what conduit, if any, to source the fulfiller's token approvals from. The zero hash signifies that no conduit should be used (and direct approvals set on Consideration).\",\"maximumFulfilled\":\"The maximum number of orders to fulfill.\",\"offerFulfillments\":\"An array of FulfillmentComponent arrays indicating which offer items to attempt to aggregate when preparing executions.\",\"recipient\":\"The intended recipient for all received items, with `address(0)` indicating that the caller should receive the items.\"},\"returns\":{\"availableOrders\":\"An array of booleans indicating if each order with an index corresponding to the index of the returned boolean was fulfillable or not.\",\"executions\":\" An array of elements indicating the sequence of transfers performed as part of matching the given orders.\"}},\"fulfillAvailableOrders(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),bytes)[],(uint256,uint256)[][],(uint256,uint256)[][],bytes32,uint256)\":{\"params\":{\"considerationFulfillments\":\"An array of FulfillmentComponent arrays indicating which consideration items to attempt to aggregate when preparing executions.\",\"fulfillerConduitKey\":\"A bytes32 value indicating what conduit, if any, to source the fulfiller's token approvals from. The zero hash signifies that no conduit should be used (and direct approvals set on Consideration).\",\"maximumFulfilled\":\"The maximum number of orders to fulfill.\",\"offerFulfillments\":\"An array of FulfillmentComponent arrays indicating which offer items to attempt to aggregate when preparing executions.\",\"orders\":\"The orders to fulfill. Note that both the offerer and the fulfiller must first approve this contract (or the corresponding conduit if indicated) to transfer any relevant tokens on their behalf and that contracts must implement `onERC1155Received` to receive ERC1155 tokens as consideration.\"},\"returns\":{\"availableOrders\":\"An array of booleans indicating if each order with an index corresponding to the index of the returned boolean was fulfillable or not.\",\"executions\":\" An array of elements indicating the sequence of transfers performed as part of matching the given orders.\"}},\"fulfillBasicOrder((address,uint256,uint256,address,address,address,uint256,uint256,uint8,uint256,uint256,bytes32,uint256,bytes32,bytes32,uint256,(uint256,address)[],bytes))\":{\"params\":{\"parameters\":\"Additional information on the fulfilled order. Note that the offerer and the fulfiller must first approve this contract (or their chosen conduit if indicated) before any tokens can be transferred. Also note that contract recipients of ERC1155 consideration items must implement `onERC1155Received` in order to receive those items.\"},\"returns\":{\"fulfilled\":\"A boolean indicating whether the order has been successfully fulfilled.\"}},\"fulfillOrder(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),bytes),bytes32)\":{\"params\":{\"fulfillerConduitKey\":\"A bytes32 value indicating what conduit, if any, to source the fulfiller's token approvals from. The zero hash signifies that no conduit should be used (and direct approvals set on Consideration).\",\"order\":\"The order to fulfill. Note that both the offerer and the fulfiller must first approve this contract (or the corresponding conduit if indicated) to transfer any relevant tokens on their behalf and that contracts must implement `onERC1155Received` to receive ERC1155 tokens as consideration.\"},\"returns\":{\"fulfilled\":\"A boolean indicating whether the order has been successfully fulfilled.\"}},\"getCounter(address)\":{\"params\":{\"offerer\":\"The offerer in question.\"},\"returns\":{\"counter\":\"The current counter.\"}},\"getOrderHash((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256))\":{\"params\":{\"order\":\"The components of the order.\"},\"returns\":{\"orderHash\":\"The order hash.\"}},\"getOrderStatus(bytes32)\":{\"params\":{\"orderHash\":\"The order hash in question.\"},\"returns\":{\"isCancelled\":\"A boolean indicating whether the order in question has been cancelled.\",\"isValidated\":\"A boolean indicating whether the order in question has been validated (i.e. previously approved or partially filled).\",\"totalFilled\":\"The total portion of the order that has been filled (i.e. the \\\"numerator\\\").\",\"totalSize\":\" The total size of the order that is either filled or unfilled (i.e. the \\\"denominator\\\").\"}},\"incrementCounter()\":{\"returns\":{\"newCounter\":\"The new counter.\"}},\"information()\":{\"returns\":{\"conduitController\":\"The conduit Controller set for this contract.\",\"domainSeparator\":\" The domain separator for this contract.\",\"version\":\" The contract version.\"}},\"matchAdvancedOrders(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),uint120,uint120,bytes,bytes)[],(uint256,uint8,uint256,uint256,bytes32[])[],((uint256,uint256)[],(uint256,uint256)[])[])\":{\"params\":{\"advancedOrders\":\"The advanced orders to match. Note that both the offerer and fulfiller on each order must first approve this contract (or their conduit if indicated by the order) to transfer any relevant tokens on their behalf and each consideration recipient must implement `onERC1155Received` in order to receive ERC1155 tokens. Also note that the offer and consideration components for each order must have no remainder after multiplying the respective amount with the supplied fraction in order for the group of partial fills to be considered valid.\",\"criteriaResolvers\":\"An array where each element contains a reference to a specific order as well as that order's offer or consideration, a token identifier, and a proof that the supplied token identifier is contained in the order's merkle root. Note that an empty root indicates that any (transferable) token identifier is valid and that no associated proof needs to be supplied.\",\"fulfillments\":\"An array of elements allocating offer components to consideration components. Note that each consideration component must be fully met in order for the match operation to be valid.\"},\"returns\":{\"executions\":\"An array of elements indicating the sequence of transfers performed as part of matching the given orders.\"}},\"matchOrders(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),bytes)[],((uint256,uint256)[],(uint256,uint256)[])[])\":{\"params\":{\"fulfillments\":\"An array of elements allocating offer components to consideration components. Note that each consideration component must be fully met in order for the match operation to be valid.\",\"orders\":\"The orders to match. Note that both the offerer and fulfiller on each order must first approve this contract (or their conduit if indicated by the order) to transfer any relevant tokens on their behalf and each consideration recipient must implement `onERC1155Received` in order to receive ERC1155 tokens.\"},\"returns\":{\"executions\":\"An array of elements indicating the sequence of transfers performed as part of matching the given orders.\"}},\"name()\":{\"returns\":{\"contractName\":\"The name of this contract.\"}},\"validate(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),bytes)[])\":{\"params\":{\"orders\":\"The orders to validate.\"},\"returns\":{\"validated\":\"A boolean indicating whether the supplied orders have been successfully validated.\"}}},\"title\":\"Seaport\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"cancel((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256)[])\":{\"notice\":\"Cancel an arbitrary number of orders. Note that only the offerer or the zone of a given order may cancel it. Callers should ensure that the intended order was cancelled by calling `getOrderStatus` and confirming that `isCancelled` returns `true`.\"},\"constructor\":{\"notice\":\"Derive and set hashes, reference chainId, and associated domain separator during deployment.\"},\"fulfillAdvancedOrder(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),uint120,uint120,bytes,bytes),(uint256,uint8,uint256,uint256,bytes32[])[],bytes32,address)\":{\"notice\":\"Fill an order, fully or partially, with an arbitrary number of items for offer and consideration alongside criteria resolvers containing specific token identifiers and associated proofs.\"},\"fulfillAvailableAdvancedOrders(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),uint120,uint120,bytes,bytes)[],(uint256,uint8,uint256,uint256,bytes32[])[],(uint256,uint256)[][],(uint256,uint256)[][],bytes32,address,uint256)\":{\"notice\":\"Attempt to fill a group of orders, fully or partially, with an arbitrary number of items for offer and consideration per order alongside criteria resolvers containing specific token identifiers and associated proofs. Any order that is not currently active, has already been fully filled, or has been cancelled will be omitted. Remaining offer and consideration items will then be aggregated where possible as indicated by the supplied offer and consideration component arrays and aggregated items will be transferred to the fulfiller or to each intended recipient, respectively. Note that a failing item transfer or an issue with order formatting will cause the entire batch to fail.\"},\"fulfillAvailableOrders(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),bytes)[],(uint256,uint256)[][],(uint256,uint256)[][],bytes32,uint256)\":{\"notice\":\"Attempt to fill a group of orders, each with an arbitrary number of items for offer and consideration. Any order that is not currently active, has already been fully filled, or has been cancelled will be omitted. Remaining offer and consideration items will then be aggregated where possible as indicated by the supplied offer and consideration component arrays and aggregated items will be transferred to the fulfiller or to each intended recipient, respectively. Note that a failing item transfer or an issue with order formatting will cause the entire batch to fail. Note that this function does not support criteria-based orders or partial filling of orders (though filling the remainder of a partially-filled order is supported).\"},\"fulfillBasicOrder((address,uint256,uint256,address,address,address,uint256,uint256,uint8,uint256,uint256,bytes32,uint256,bytes32,bytes32,uint256,(uint256,address)[],bytes))\":{\"notice\":\"Fulfill an order offering an ERC20, ERC721, or ERC1155 item by supplying Ether (or other native tokens), ERC20 tokens, an ERC721 item, or an ERC1155 item as consideration. Six permutations are supported: Native token to ERC721, Native token to ERC1155, ERC20 to ERC721, ERC20 to ERC1155, ERC721 to ERC20, and ERC1155 to ERC20 (with native tokens supplied as msg.value). For an order to be eligible for fulfillment via this method, it must contain a single offer item (though that item may have a greater amount if the item is not an ERC721). An arbitrary number of \\\"additional recipients\\\" may also be supplied which will each receive native tokens or ERC20 items from the fulfiller as consideration. Refer to the documentation for a more comprehensive summary of how to utilize this method and what orders are compatible with it.\"},\"fulfillOrder(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),bytes),bytes32)\":{\"notice\":\"Fulfill an order with an arbitrary number of items for offer and consideration. Note that this function does not support criteria-based orders or partial filling of orders (though filling the remainder of a partially-filled order is supported).\"},\"getCounter(address)\":{\"notice\":\"Retrieve the current counter for a given offerer.\"},\"getOrderHash((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256))\":{\"notice\":\"Retrieve the order hash for a given order.\"},\"getOrderStatus(bytes32)\":{\"notice\":\"Retrieve the status of a given order by hash, including whether the order has been cancelled or validated and the fraction of the order that has been filled.\"},\"incrementCounter()\":{\"notice\":\"Cancel all orders from a given offerer with a given zone in bulk by incrementing a counter. Note that only the offerer may increment the counter.\"},\"information()\":{\"notice\":\"Retrieve configuration information for this contract.\"},\"matchAdvancedOrders(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),uint120,uint120,bytes,bytes)[],(uint256,uint8,uint256,uint256,bytes32[])[],((uint256,uint256)[],(uint256,uint256)[])[])\":{\"notice\":\"Match an arbitrary number of full or partial orders, each with an arbitrary number of items for offer and consideration, supplying criteria resolvers containing specific token identifiers and associated proofs as well as fulfillments allocating offer components to consideration components.\"},\"matchOrders(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),bytes)[],((uint256,uint256)[],(uint256,uint256)[])[])\":{\"notice\":\"Match an arbitrary number of orders, each with an arbitrary number of items for offer and consideration along with a set of fulfillments allocating offer components to consideration components. Note that this function does not support criteria-based or partial filling of orders (though filling the remainder of a partially-filled order is supported).\"},\"name()\":{\"notice\":\"Retrieve the name of this contract.\"},\"validate(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),bytes)[])\":{\"notice\":\"Validate an arbitrary number of orders, thereby registering their signatures as valid and allowing the fulfiller to skip signature verification on fulfillment. Note that validated orders may still be unfulfillable due to invalid item amounts or other factors; callers should determine whether validated orders are fulfillable by simulating the fulfillment call prior to execution. Also note that anyone can validate a signed order, but only the offerer can validate an order without supplying a signature.\"}},\"notice\":\"Seaport is a generalized ETH/ERC20/ERC721/ERC1155 marketplace. It minimizes external calls to the greatest extent possible and provides lightweight methods for common routes as well as more flexible methods for composing advanced orders or groups of orders. Each order contains an arbitrary number of items that may be spent (the \\\"offer\\\") along with an arbitrary number of items that must be received back by the indicated recipients (the \\\"consideration\\\").\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/Seaport.sol\":\"Seaport\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":19066},\"remappings\":[],\"viaIR\":true},\"sources\":{\"contracts/Seaport.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.13;\\n\\nimport { Consideration } from \\\"./lib/Consideration.sol\\\";\\n\\n/**\\n * @title Seaport\\n * @custom:version 1.1\\n * @author 0age (0age.eth)\\n * @custom:coauthor d1ll0n (d1ll0n.eth)\\n * @custom:coauthor transmissions11 (t11s.eth)\\n * @custom:contributor Kartik (slokh.eth)\\n * @custom:contributor LeFevre (lefevre.eth)\\n * @custom:contributor Joseph Schiarizzi (CupOJoseph.eth)\\n * @custom:contributor Aspyn Palatnick (stuckinaboot.eth)\\n * @custom:contributor James Wenzel (emo.eth)\\n * @custom:contributor Stephan Min (stephanm.eth)\\n * @custom:contributor Ryan Ghods (ralxz.eth)\\n * @custom:contributor hack3r-0m (hack3r-0m.eth)\\n * @custom:contributor Diego Estevez (antidiego.eth)\\n * @custom:contributor Chomtana (chomtana.eth)\\n * @custom:contributor Saw-mon and Natalie (sawmonandnatalie.eth)\\n * @custom:contributor 0xBeans (0xBeans.eth)\\n * @custom:contributor 0x4non (punkdev.eth)\\n * @custom:contributor Laurence E. Day (norsefire.eth)\\n * @custom:contributor vectorized.eth (vectorized.eth)\\n * @custom:contributor karmacoma (karmacoma.eth)\\n * @custom:contributor horsefacts (horsefacts.eth)\\n * @custom:contributor UncarvedBlock (uncarvedblock.eth)\\n * @custom:contributor Zoraiz Mahmood (zorz.eth)\\n * @custom:contributor William Poulin (wpoulin.eth)\\n * @custom:contributor Rajiv Patel-O'Connor (rajivpoc.eth)\\n * @custom:contributor tserg (tserg.eth)\\n * @custom:contributor cygaar (cygaar.eth)\\n * @custom:contributor Meta0xNull (meta0xnull.eth)\\n * @custom:contributor gpersoon (gpersoon.eth)\\n * @custom:contributor Matt Solomon (msolomon.eth)\\n * @custom:contributor Weikang Song (weikangs.eth)\\n * @custom:contributor zer0dot (zer0dot.eth)\\n * @custom:contributor Mudit Gupta (mudit.eth)\\n * @custom:contributor leonardoalt (leoalt.eth)\\n * @custom:contributor cmichel (cmichel.eth)\\n * @custom:contributor PraneshASP (pranesh.eth)\\n * @custom:contributor JasperAlexander (jasperalexander.eth)\\n * @custom:contributor Ellahi (ellahi.eth)\\n * @custom:contributor zaz (1zaz1.eth)\\n * @custom:contributor berndartmueller (berndartmueller.eth)\\n * @custom:contributor dmfxyz (dmfxyz.eth)\\n * @custom:contributor daltoncoder (dontkillrobots.eth)\\n * @custom:contributor 0xf4ce (0xf4ce.eth)\\n * @custom:contributor phaze (phaze.eth)\\n * @custom:contributor hrkrshnn (hrkrshnn.eth)\\n * @custom:contributor axic (axic.eth)\\n * @custom:contributor leastwood (leastwood.eth)\\n * @custom:contributor 0xsanson (sanson.eth)\\n * @custom:contributor blockdev (blockd3v.eth)\\n * @custom:contributor fiveoutofnine (fiveoutofnine.eth)\\n * @custom:contributor shuklaayush (shuklaayush.eth)\\n * @custom:contributor 0xPatissier\\n * @custom:contributor pcaversaccio\\n * @custom:contributor David Eiber\\n * @custom:contributor csanuragjain\\n * @custom:contributor sach1r0\\n * @custom:contributor twojoy0\\n * @custom:contributor ori_dabush\\n * @custom:contributor Daniel Gelfand\\n * @custom:contributor okkothejawa\\n * @custom:contributor FlameHorizon\\n * @custom:contributor vdrg\\n * @custom:contributor dmitriia\\n * @custom:contributor bokeh-eth\\n * @custom:contributor asutorufos\\n * @custom:contributor rfart(rfa)\\n * @custom:contributor Riley Holterhus\\n * @custom:contributor big-tech-sux\\n * @notice Seaport is a generalized ETH/ERC20/ERC721/ERC1155 marketplace. It\\n * minimizes external calls to the greatest extent possible and provides\\n * lightweight methods for common routes as well as more flexible\\n * methods for composing advanced orders or groups of orders. Each order\\n * contains an arbitrary number of items that may be spent (the \\\"offer\\\")\\n * along with an arbitrary number of items that must be received back by\\n * the indicated recipients (the \\\"consideration\\\").\\n */\\ncontract Seaport is Consideration {\\n /**\\n * @notice Derive and set hashes, reference chainId, and associated domain\\n * separator during deployment.\\n *\\n * @param conduitController A contract that deploys conduits, or proxies\\n * that may optionally be used to transfer approved\\n * ERC20/721/1155 tokens.\\n */\\n constructor(address conduitController) Consideration(conduitController) {}\\n\\n /**\\n * @dev Internal pure function to retrieve and return the name of this\\n * contract.\\n *\\n * @return The name of this contract.\\n */\\n function _name() internal pure override returns (string memory) {\\n // Return the name of the contract.\\n assembly {\\n mstore(0x20, 0x20)\\n mstore(0x47, 0x07536561706f7274)\\n return(0x20, 0x60)\\n }\\n }\\n\\n /**\\n * @dev Internal pure function to retrieve the name of this contract as a\\n * string that will be used to derive the name hash in the constructor.\\n *\\n * @return The name of this contract as a string.\\n */\\n function _nameString() internal pure override returns (string memory) {\\n // Return the name of the contract.\\n return \\\"Seaport\\\";\\n }\\n}\\n\",\"keccak256\":\"0x1bfc80f44ad243edd4d625d7c388e7ff2a03844da69742250200147d3103a693\",\"license\":\"MIT\"},\"contracts/conduit/lib/ConduitEnums.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.7;\\n\\nenum ConduitItemType {\\n NATIVE, // unused\\n ERC20,\\n ERC721,\\n ERC1155\\n}\\n\",\"keccak256\":\"0x3a9ecf77688f97d1b595be27b49fca3eac93e3f91160d79f0f0063c250fd8aca\",\"license\":\"MIT\"},\"contracts/conduit/lib/ConduitStructs.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.7;\\n\\nimport { ConduitItemType } from \\\"./ConduitEnums.sol\\\";\\n\\nstruct ConduitTransfer {\\n ConduitItemType itemType;\\n address token;\\n address from;\\n address to;\\n uint256 identifier;\\n uint256 amount;\\n}\\n\\nstruct ConduitBatch1155Transfer {\\n address token;\\n address from;\\n address to;\\n uint256[] ids;\\n uint256[] amounts;\\n}\\n\",\"keccak256\":\"0xfd2cec45327e9a6ebc02d7efb9daa1cfdabb26eb803e4b2e9b5e82340d92cfed\",\"license\":\"MIT\"},\"contracts/interfaces/AmountDerivationErrors.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.7;\\n\\n/**\\n * @title AmountDerivationErrors\\n * @author 0age\\n * @notice AmountDerivationErrors contains errors related to amount derivation.\\n */\\ninterface AmountDerivationErrors {\\n /**\\n * @dev Revert with an error when attempting to apply a fraction as part of\\n * a partial fill that does not divide the target amount cleanly.\\n */\\n error InexactFraction();\\n}\\n\",\"keccak256\":\"0x1cba27c1c5510ec735e47d5b8f98b50bcf5f96884f8b1a6367987fff7cdc2735\",\"license\":\"MIT\"},\"contracts/interfaces/ConduitControllerInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.7;\\n\\n/**\\n * @title ConduitControllerInterface\\n * @author 0age\\n * @notice ConduitControllerInterface contains all external function interfaces,\\n * structs, events, and errors for the conduit controller.\\n */\\ninterface ConduitControllerInterface {\\n /**\\n * @dev Track the conduit key, current owner, new potential owner, and open\\n * channels for each deployed conduit.\\n */\\n struct ConduitProperties {\\n bytes32 key;\\n address owner;\\n address potentialOwner;\\n address[] channels;\\n mapping(address => uint256) channelIndexesPlusOne;\\n }\\n\\n /**\\n * @dev Emit an event whenever a new conduit is created.\\n *\\n * @param conduit The newly created conduit.\\n * @param conduitKey The conduit key used to create the new conduit.\\n */\\n event NewConduit(address conduit, bytes32 conduitKey);\\n\\n /**\\n * @dev Emit an event whenever conduit ownership is transferred.\\n *\\n * @param conduit The conduit for which ownership has been\\n * transferred.\\n * @param previousOwner The previous owner of the conduit.\\n * @param newOwner The new owner of the conduit.\\n */\\n event OwnershipTransferred(\\n address indexed conduit,\\n address indexed previousOwner,\\n address indexed newOwner\\n );\\n\\n /**\\n * @dev Emit an event whenever a conduit owner registers a new potential\\n * owner for that conduit.\\n *\\n * @param newPotentialOwner The new potential owner of the conduit.\\n */\\n event PotentialOwnerUpdated(address indexed newPotentialOwner);\\n\\n /**\\n * @dev Revert with an error when attempting to create a new conduit using a\\n * conduit key where the first twenty bytes of the key do not match the\\n * address of the caller.\\n */\\n error InvalidCreator();\\n\\n /**\\n * @dev Revert with an error when attempting to create a new conduit when no\\n * initial owner address is supplied.\\n */\\n error InvalidInitialOwner();\\n\\n /**\\n * @dev Revert with an error when attempting to set a new potential owner\\n * that is already set.\\n */\\n error NewPotentialOwnerAlreadySet(\\n address conduit,\\n address newPotentialOwner\\n );\\n\\n /**\\n * @dev Revert with an error when attempting to cancel ownership transfer\\n * when no new potential owner is currently set.\\n */\\n error NoPotentialOwnerCurrentlySet(address conduit);\\n\\n /**\\n * @dev Revert with an error when attempting to interact with a conduit that\\n * does not yet exist.\\n */\\n error NoConduit();\\n\\n /**\\n * @dev Revert with an error when attempting to create a conduit that\\n * already exists.\\n */\\n error ConduitAlreadyExists(address conduit);\\n\\n /**\\n * @dev Revert with an error when attempting to update channels or transfer\\n * ownership of a conduit when the caller is not the owner of the\\n * conduit in question.\\n */\\n error CallerIsNotOwner(address conduit);\\n\\n /**\\n * @dev Revert with an error when attempting to register a new potential\\n * owner and supplying the null address.\\n */\\n error NewPotentialOwnerIsZeroAddress(address conduit);\\n\\n /**\\n * @dev Revert with an error when attempting to claim ownership of a conduit\\n * with a caller that is not the current potential owner for the\\n * conduit in question.\\n */\\n error CallerIsNotNewPotentialOwner(address conduit);\\n\\n /**\\n * @dev Revert with an error when attempting to retrieve a channel using an\\n * index that is out of range.\\n */\\n error ChannelOutOfRange(address conduit);\\n\\n /**\\n * @notice Deploy a new conduit using a supplied conduit key and assigning\\n * an initial owner for the deployed conduit. Note that the first\\n * twenty bytes of the supplied conduit key must match the caller\\n * and that a new conduit cannot be created if one has already been\\n * deployed using the same conduit key.\\n *\\n * @param conduitKey The conduit key used to deploy the conduit. Note that\\n * the first twenty bytes of the conduit key must match\\n * the caller of this contract.\\n * @param initialOwner The initial owner to set for the new conduit.\\n *\\n * @return conduit The address of the newly deployed conduit.\\n */\\n function createConduit(bytes32 conduitKey, address initialOwner)\\n external\\n returns (address conduit);\\n\\n /**\\n * @notice Open or close a channel on a given conduit, thereby allowing the\\n * specified account to execute transfers against that conduit.\\n * Extreme care must be taken when updating channels, as malicious\\n * or vulnerable channels can transfer any ERC20, ERC721 and ERC1155\\n * tokens where the token holder has granted the conduit approval.\\n * Only the owner of the conduit in question may call this function.\\n *\\n * @param conduit The conduit for which to open or close the channel.\\n * @param channel The channel to open or close on the conduit.\\n * @param isOpen A boolean indicating whether to open or close the channel.\\n */\\n function updateChannel(\\n address conduit,\\n address channel,\\n bool isOpen\\n ) external;\\n\\n /**\\n * @notice Initiate conduit ownership transfer by assigning a new potential\\n * owner for the given conduit. Once set, the new potential owner\\n * may call `acceptOwnership` to claim ownership of the conduit.\\n * Only the owner of the conduit in question may call this function.\\n *\\n * @param conduit The conduit for which to initiate ownership transfer.\\n * @param newPotentialOwner The new potential owner of the conduit.\\n */\\n function transferOwnership(address conduit, address newPotentialOwner)\\n external;\\n\\n /**\\n * @notice Clear the currently set potential owner, if any, from a conduit.\\n * Only the owner of the conduit in question may call this function.\\n *\\n * @param conduit The conduit for which to cancel ownership transfer.\\n */\\n function cancelOwnershipTransfer(address conduit) external;\\n\\n /**\\n * @notice Accept ownership of a supplied conduit. Only accounts that the\\n * current owner has set as the new potential owner may call this\\n * function.\\n *\\n * @param conduit The conduit for which to accept ownership.\\n */\\n function acceptOwnership(address conduit) external;\\n\\n /**\\n * @notice Retrieve the current owner of a deployed conduit.\\n *\\n * @param conduit The conduit for which to retrieve the associated owner.\\n *\\n * @return owner The owner of the supplied conduit.\\n */\\n function ownerOf(address conduit) external view returns (address owner);\\n\\n /**\\n * @notice Retrieve the conduit key for a deployed conduit via reverse\\n * lookup.\\n *\\n * @param conduit The conduit for which to retrieve the associated conduit\\n * key.\\n *\\n * @return conduitKey The conduit key used to deploy the supplied conduit.\\n */\\n function getKey(address conduit) external view returns (bytes32 conduitKey);\\n\\n /**\\n * @notice Derive the conduit associated with a given conduit key and\\n * determine whether that conduit exists (i.e. whether it has been\\n * deployed).\\n *\\n * @param conduitKey The conduit key used to derive the conduit.\\n *\\n * @return conduit The derived address of the conduit.\\n * @return exists A boolean indicating whether the derived conduit has been\\n * deployed or not.\\n */\\n function getConduit(bytes32 conduitKey)\\n external\\n view\\n returns (address conduit, bool exists);\\n\\n /**\\n * @notice Retrieve the potential owner, if any, for a given conduit. The\\n * current owner may set a new potential owner via\\n * `transferOwnership` and that owner may then accept ownership of\\n * the conduit in question via `acceptOwnership`.\\n *\\n * @param conduit The conduit for which to retrieve the potential owner.\\n *\\n * @return potentialOwner The potential owner, if any, for the conduit.\\n */\\n function getPotentialOwner(address conduit)\\n external\\n view\\n returns (address potentialOwner);\\n\\n /**\\n * @notice Retrieve the status (either open or closed) of a given channel on\\n * a conduit.\\n *\\n * @param conduit The conduit for which to retrieve the channel status.\\n * @param channel The channel for which to retrieve the status.\\n *\\n * @return isOpen The status of the channel on the given conduit.\\n */\\n function getChannelStatus(address conduit, address channel)\\n external\\n view\\n returns (bool isOpen);\\n\\n /**\\n * @notice Retrieve the total number of open channels for a given conduit.\\n *\\n * @param conduit The conduit for which to retrieve the total channel count.\\n *\\n * @return totalChannels The total number of open channels for the conduit.\\n */\\n function getTotalChannels(address conduit)\\n external\\n view\\n returns (uint256 totalChannels);\\n\\n /**\\n * @notice Retrieve an open channel at a specific index for a given conduit.\\n * Note that the index of a channel can change as a result of other\\n * channels being closed on the conduit.\\n *\\n * @param conduit The conduit for which to retrieve the open channel.\\n * @param channelIndex The index of the channel in question.\\n *\\n * @return channel The open channel, if any, at the specified channel index.\\n */\\n function getChannel(address conduit, uint256 channelIndex)\\n external\\n view\\n returns (address channel);\\n\\n /**\\n * @notice Retrieve all open channels for a given conduit. Note that calling\\n * this function for a conduit with many channels will revert with\\n * an out-of-gas error.\\n *\\n * @param conduit The conduit for which to retrieve open channels.\\n *\\n * @return channels An array of open channels on the given conduit.\\n */\\n function getChannels(address conduit)\\n external\\n view\\n returns (address[] memory channels);\\n\\n /**\\n * @dev Retrieve the conduit creation code and runtime code hashes.\\n */\\n function getConduitCodeHashes()\\n external\\n view\\n returns (bytes32 creationCodeHash, bytes32 runtimeCodeHash);\\n}\\n\",\"keccak256\":\"0xc38cd5d6f7f6ea6c94c54ef401d702b352ddf6c907590305c4bf45e9b4fe8f36\",\"license\":\"MIT\"},\"contracts/interfaces/ConduitInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.7;\\n\\n// prettier-ignore\\nimport {\\n ConduitTransfer,\\n ConduitBatch1155Transfer\\n} from \\\"../conduit/lib/ConduitStructs.sol\\\";\\n\\n/**\\n * @title ConduitInterface\\n * @author 0age\\n * @notice ConduitInterface contains all external function interfaces, events,\\n * and errors for conduit contracts.\\n */\\ninterface ConduitInterface {\\n /**\\n * @dev Revert with an error when attempting to execute transfers using a\\n * caller that does not have an open channel.\\n */\\n error ChannelClosed(address channel);\\n\\n /**\\n * @dev Revert with an error when attempting to update a channel to the\\n * current status of that channel.\\n */\\n error ChannelStatusAlreadySet(address channel, bool isOpen);\\n\\n /**\\n * @dev Revert with an error when attempting to execute a transfer for an\\n * item that does not have an ERC20/721/1155 item type.\\n */\\n error InvalidItemType();\\n\\n /**\\n * @dev Revert with an error when attempting to update the status of a\\n * channel from a caller that is not the conduit controller.\\n */\\n error InvalidController();\\n\\n /**\\n * @dev Emit an event whenever a channel is opened or closed.\\n *\\n * @param channel The channel that has been updated.\\n * @param open A boolean indicating whether the conduit is open or not.\\n */\\n event ChannelUpdated(address indexed channel, bool open);\\n\\n /**\\n * @notice Execute a sequence of ERC20/721/1155 transfers. Only a caller\\n * with an open channel can call this function.\\n *\\n * @param transfers The ERC20/721/1155 transfers to perform.\\n *\\n * @return magicValue A magic value indicating that the transfers were\\n * performed successfully.\\n */\\n function execute(ConduitTransfer[] calldata transfers)\\n external\\n returns (bytes4 magicValue);\\n\\n /**\\n * @notice Execute a sequence of batch 1155 transfers. Only a caller with an\\n * open channel can call this function.\\n *\\n * @param batch1155Transfers The 1155 batch transfers to perform.\\n *\\n * @return magicValue A magic value indicating that the transfers were\\n * performed successfully.\\n */\\n function executeBatch1155(\\n ConduitBatch1155Transfer[] calldata batch1155Transfers\\n ) external returns (bytes4 magicValue);\\n\\n /**\\n * @notice Execute a sequence of transfers, both single and batch 1155. Only\\n * a caller with an open channel can call this function.\\n *\\n * @param standardTransfers The ERC20/721/1155 transfers to perform.\\n * @param batch1155Transfers The 1155 batch transfers to perform.\\n *\\n * @return magicValue A magic value indicating that the transfers were\\n * performed successfully.\\n */\\n function executeWithBatch1155(\\n ConduitTransfer[] calldata standardTransfers,\\n ConduitBatch1155Transfer[] calldata batch1155Transfers\\n ) external returns (bytes4 magicValue);\\n\\n /**\\n * @notice Open or close a given channel. Only callable by the controller.\\n *\\n * @param channel The channel to open or close.\\n * @param isOpen The status of the channel (either open or closed).\\n */\\n function updateChannel(address channel, bool isOpen) external;\\n}\\n\",\"keccak256\":\"0xbfcd43fd8c0f3eccfb6b5c10a4c4b794f3004ff08152116f8b1ea6512af336e1\",\"license\":\"MIT\"},\"contracts/interfaces/ConsiderationEventsAndErrors.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.7;\\n\\nimport { SpentItem, ReceivedItem } from \\\"../lib/ConsiderationStructs.sol\\\";\\n\\n/**\\n * @title ConsiderationEventsAndErrors\\n * @author 0age\\n * @notice ConsiderationEventsAndErrors contains all events and errors.\\n */\\ninterface ConsiderationEventsAndErrors {\\n /**\\n * @dev Emit an event whenever an order is successfully fulfilled.\\n *\\n * @param orderHash The hash of the fulfilled order.\\n * @param offerer The offerer of the fulfilled order.\\n * @param zone The zone of the fulfilled order.\\n * @param recipient The recipient of each spent item on the fulfilled\\n * order, or the null address if there is no specific\\n * fulfiller (i.e. the order is part of a group of\\n * orders). Defaults to the caller unless explicitly\\n * specified otherwise by the fulfiller.\\n * @param offer The offer items spent as part of the order.\\n * @param consideration The consideration items received as part of the\\n * order along with the recipients of each item.\\n */\\n event OrderFulfilled(\\n bytes32 orderHash,\\n address indexed offerer,\\n address indexed zone,\\n address recipient,\\n SpentItem[] offer,\\n ReceivedItem[] consideration\\n );\\n\\n /**\\n * @dev Emit an event whenever an order is successfully cancelled.\\n *\\n * @param orderHash The hash of the cancelled order.\\n * @param offerer The offerer of the cancelled order.\\n * @param zone The zone of the cancelled order.\\n */\\n event OrderCancelled(\\n bytes32 orderHash,\\n address indexed offerer,\\n address indexed zone\\n );\\n\\n /**\\n * @dev Emit an event whenever an order is explicitly validated. Note that\\n * this event will not be emitted on partial fills even though they do\\n * validate the order as part of partial fulfillment.\\n *\\n * @param orderHash The hash of the validated order.\\n * @param offerer The offerer of the validated order.\\n * @param zone The zone of the validated order.\\n */\\n event OrderValidated(\\n bytes32 orderHash,\\n address indexed offerer,\\n address indexed zone\\n );\\n\\n /**\\n * @dev Emit an event whenever a counter for a given offerer is incremented.\\n *\\n * @param newCounter The new counter for the offerer.\\n * @param offerer The offerer in question.\\n */\\n event CounterIncremented(uint256 newCounter, address indexed offerer);\\n\\n /**\\n * @dev Revert with an error when attempting to fill an order that has\\n * already been fully filled.\\n *\\n * @param orderHash The order hash on which a fill was attempted.\\n */\\n error OrderAlreadyFilled(bytes32 orderHash);\\n\\n /**\\n * @dev Revert with an error when attempting to fill an order outside the\\n * specified start time and end time.\\n */\\n error InvalidTime();\\n\\n /**\\n * @dev Revert with an error when attempting to fill an order referencing an\\n * invalid conduit (i.e. one that has not been deployed).\\n */\\n error InvalidConduit(bytes32 conduitKey, address conduit);\\n\\n /**\\n * @dev Revert with an error when an order is supplied for fulfillment with\\n * a consideration array that is shorter than the original array.\\n */\\n error MissingOriginalConsiderationItems();\\n\\n /**\\n * @dev Revert with an error when a call to a conduit fails with revert data\\n * that is too expensive to return.\\n */\\n error InvalidCallToConduit(address conduit);\\n\\n /**\\n * @dev Revert with an error if a consideration amount has not been fully\\n * zeroed out after applying all fulfillments.\\n *\\n * @param orderIndex The index of the order with the consideration\\n * item with a shortfall.\\n * @param considerationIndex The index of the consideration item on the\\n * order.\\n * @param shortfallAmount The unfulfilled consideration amount.\\n */\\n error ConsiderationNotMet(\\n uint256 orderIndex,\\n uint256 considerationIndex,\\n uint256 shortfallAmount\\n );\\n\\n /**\\n * @dev Revert with an error when insufficient ether is supplied as part of\\n * msg.value when fulfilling orders.\\n */\\n error InsufficientEtherSupplied();\\n\\n /**\\n * @dev Revert with an error when an ether transfer reverts.\\n */\\n error EtherTransferGenericFailure(address account, uint256 amount);\\n\\n /**\\n * @dev Revert with an error when a partial fill is attempted on an order\\n * that does not specify partial fill support in its order type.\\n */\\n error PartialFillsNotEnabledForOrder();\\n\\n /**\\n * @dev Revert with an error when attempting to fill an order that has been\\n * cancelled.\\n *\\n * @param orderHash The hash of the cancelled order.\\n */\\n error OrderIsCancelled(bytes32 orderHash);\\n\\n /**\\n * @dev Revert with an error when attempting to fill a basic order that has\\n * been partially filled.\\n *\\n * @param orderHash The hash of the partially used order.\\n */\\n error OrderPartiallyFilled(bytes32 orderHash);\\n\\n /**\\n * @dev Revert with an error when attempting to cancel an order as a caller\\n * other than the indicated offerer or zone.\\n */\\n error InvalidCanceller();\\n\\n /**\\n * @dev Revert with an error when supplying a fraction with a value of zero\\n * for the numerator or denominator, or one where the numerator exceeds\\n * the denominator.\\n */\\n error BadFraction();\\n\\n /**\\n * @dev Revert with an error when a caller attempts to supply callvalue to a\\n * non-payable basic order route or does not supply any callvalue to a\\n * payable basic order route.\\n */\\n error InvalidMsgValue(uint256 value);\\n\\n /**\\n * @dev Revert with an error when attempting to fill a basic order using\\n * calldata not produced by default ABI encoding.\\n */\\n error InvalidBasicOrderParameterEncoding();\\n\\n /**\\n * @dev Revert with an error when attempting to fulfill any number of\\n * available orders when none are fulfillable.\\n */\\n error NoSpecifiedOrdersAvailable();\\n\\n /**\\n * @dev Revert with an error when attempting to fulfill an order with an\\n * offer for ETH outside of matching orders.\\n */\\n error InvalidNativeOfferItem();\\n}\\n\",\"keccak256\":\"0xcccd88b20308035e9fe05c7a81294e6a028ad9fb4a1de32ebb71b4dc6d30772b\",\"license\":\"MIT\"},\"contracts/interfaces/ConsiderationInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.7;\\n\\n// prettier-ignore\\nimport {\\n BasicOrderParameters,\\n OrderComponents,\\n Fulfillment,\\n FulfillmentComponent,\\n Execution,\\n Order,\\n AdvancedOrder,\\n OrderStatus,\\n CriteriaResolver\\n} from \\\"../lib/ConsiderationStructs.sol\\\";\\n\\n/**\\n * @title ConsiderationInterface\\n * @author 0age\\n * @custom:version 1.1\\n * @notice Consideration is a generalized ETH/ERC20/ERC721/ERC1155 marketplace.\\n * It minimizes external calls to the greatest extent possible and\\n * provides lightweight methods for common routes as well as more\\n * flexible methods for composing advanced orders.\\n *\\n * @dev ConsiderationInterface contains all external function interfaces for\\n * Consideration.\\n */\\ninterface ConsiderationInterface {\\n /**\\n * @notice Fulfill an order offering an ERC721 token by supplying Ether (or\\n * the native token for the given chain) as consideration for the\\n * order. An arbitrary number of \\\"additional recipients\\\" may also be\\n * supplied which will each receive native tokens from the fulfiller\\n * as consideration.\\n *\\n * @param parameters Additional information on the fulfilled order. Note\\n * that the offerer must first approve this contract (or\\n * their preferred conduit if indicated by the order) for\\n * their offered ERC721 token to be transferred.\\n *\\n * @return fulfilled A boolean indicating whether the order has been\\n * successfully fulfilled.\\n */\\n function fulfillBasicOrder(BasicOrderParameters calldata parameters)\\n external\\n payable\\n returns (bool fulfilled);\\n\\n /**\\n * @notice Fulfill an order with an arbitrary number of items for offer and\\n * consideration. Note that this function does not support\\n * criteria-based orders or partial filling of orders (though\\n * filling the remainder of a partially-filled order is supported).\\n *\\n * @param order The order to fulfill. Note that both the\\n * offerer and the fulfiller must first approve\\n * this contract (or the corresponding conduit if\\n * indicated) to transfer any relevant tokens on\\n * their behalf and that contracts must implement\\n * `onERC1155Received` to receive ERC1155 tokens\\n * as consideration.\\n * @param fulfillerConduitKey A bytes32 value indicating what conduit, if\\n * any, to source the fulfiller's token approvals\\n * from. The zero hash signifies that no conduit\\n * should be used, with direct approvals set on\\n * Consideration.\\n *\\n * @return fulfilled A boolean indicating whether the order has been\\n * successfully fulfilled.\\n */\\n function fulfillOrder(Order calldata order, bytes32 fulfillerConduitKey)\\n external\\n payable\\n returns (bool fulfilled);\\n\\n /**\\n * @notice Fill an order, fully or partially, with an arbitrary number of\\n * items for offer and consideration alongside criteria resolvers\\n * containing specific token identifiers and associated proofs.\\n *\\n * @param advancedOrder The order to fulfill along with the fraction\\n * of the order to attempt to fill. Note that\\n * both the offerer and the fulfiller must first\\n * approve this contract (or their preferred\\n * conduit if indicated by the order) to transfer\\n * any relevant tokens on their behalf and that\\n * contracts must implement `onERC1155Received`\\n * to receive ERC1155 tokens as consideration.\\n * Also note that all offer and consideration\\n * components must have no remainder after\\n * multiplication of the respective amount with\\n * the supplied fraction for the partial fill to\\n * be considered valid.\\n * @param criteriaResolvers An array where each element contains a\\n * reference to a specific offer or\\n * consideration, a token identifier, and a proof\\n * that the supplied token identifier is\\n * contained in the merkle root held by the item\\n * in question's criteria element. Note that an\\n * empty criteria indicates that any\\n * (transferable) token identifier on the token\\n * in question is valid and that no associated\\n * proof needs to be supplied.\\n * @param fulfillerConduitKey A bytes32 value indicating what conduit, if\\n * any, to source the fulfiller's token approvals\\n * from. The zero hash signifies that no conduit\\n * should be used, with direct approvals set on\\n * Consideration.\\n * @param recipient The intended recipient for all received items,\\n * with `address(0)` indicating that the caller\\n * should receive the items.\\n *\\n * @return fulfilled A boolean indicating whether the order has been\\n * successfully fulfilled.\\n */\\n function fulfillAdvancedOrder(\\n AdvancedOrder calldata advancedOrder,\\n CriteriaResolver[] calldata criteriaResolvers,\\n bytes32 fulfillerConduitKey,\\n address recipient\\n ) external payable returns (bool fulfilled);\\n\\n /**\\n * @notice Attempt to fill a group of orders, each with an arbitrary number\\n * of items for offer and consideration. Any order that is not\\n * currently active, has already been fully filled, or has been\\n * cancelled will be omitted. Remaining offer and consideration\\n * items will then be aggregated where possible as indicated by the\\n * supplied offer and consideration component arrays and aggregated\\n * items will be transferred to the fulfiller or to each intended\\n * recipient, respectively. Note that a failing item transfer or an\\n * issue with order formatting will cause the entire batch to fail.\\n * Note that this function does not support criteria-based orders or\\n * partial filling of orders (though filling the remainder of a\\n * partially-filled order is supported).\\n *\\n * @param orders The orders to fulfill. Note that both\\n * the offerer and the fulfiller must first\\n * approve this contract (or the\\n * corresponding conduit if indicated) to\\n * transfer any relevant tokens on their\\n * behalf and that contracts must implement\\n * `onERC1155Received` to receive ERC1155\\n * tokens as consideration.\\n * @param offerFulfillments An array of FulfillmentComponent arrays\\n * indicating which offer items to attempt\\n * to aggregate when preparing executions.\\n * @param considerationFulfillments An array of FulfillmentComponent arrays\\n * indicating which consideration items to\\n * attempt to aggregate when preparing\\n * executions.\\n * @param fulfillerConduitKey A bytes32 value indicating what conduit,\\n * if any, to source the fulfiller's token\\n * approvals from. The zero hash signifies\\n * that no conduit should be used, with\\n * direct approvals set on this contract.\\n * @param maximumFulfilled The maximum number of orders to fulfill.\\n *\\n * @return availableOrders An array of booleans indicating if each order\\n * with an index corresponding to the index of the\\n * returned boolean was fulfillable or not.\\n * @return executions An array of elements indicating the sequence of\\n * transfers performed as part of matching the given\\n * orders.\\n */\\n function fulfillAvailableOrders(\\n Order[] calldata orders,\\n FulfillmentComponent[][] calldata offerFulfillments,\\n FulfillmentComponent[][] calldata considerationFulfillments,\\n bytes32 fulfillerConduitKey,\\n uint256 maximumFulfilled\\n )\\n external\\n payable\\n returns (bool[] memory availableOrders, Execution[] memory executions);\\n\\n /**\\n * @notice Attempt to fill a group of orders, fully or partially, with an\\n * arbitrary number of items for offer and consideration per order\\n * alongside criteria resolvers containing specific token\\n * identifiers and associated proofs. Any order that is not\\n * currently active, has already been fully filled, or has been\\n * cancelled will be omitted. Remaining offer and consideration\\n * items will then be aggregated where possible as indicated by the\\n * supplied offer and consideration component arrays and aggregated\\n * items will be transferred to the fulfiller or to each intended\\n * recipient, respectively. Note that a failing item transfer or an\\n * issue with order formatting will cause the entire batch to fail.\\n *\\n * @param advancedOrders The orders to fulfill along with the\\n * fraction of those orders to attempt to\\n * fill. Note that both the offerer and the\\n * fulfiller must first approve this\\n * contract (or their preferred conduit if\\n * indicated by the order) to transfer any\\n * relevant tokens on their behalf and that\\n * contracts must implement\\n * `onERC1155Received` to enable receipt of\\n * ERC1155 tokens as consideration. Also\\n * note that all offer and consideration\\n * components must have no remainder after\\n * multiplication of the respective amount\\n * with the supplied fraction for an\\n * order's partial fill amount to be\\n * considered valid.\\n * @param criteriaResolvers An array where each element contains a\\n * reference to a specific offer or\\n * consideration, a token identifier, and a\\n * proof that the supplied token identifier\\n * is contained in the merkle root held by\\n * the item in question's criteria element.\\n * Note that an empty criteria indicates\\n * that any (transferable) token\\n * identifier on the token in question is\\n * valid and that no associated proof needs\\n * to be supplied.\\n * @param offerFulfillments An array of FulfillmentComponent arrays\\n * indicating which offer items to attempt\\n * to aggregate when preparing executions.\\n * @param considerationFulfillments An array of FulfillmentComponent arrays\\n * indicating which consideration items to\\n * attempt to aggregate when preparing\\n * executions.\\n * @param fulfillerConduitKey A bytes32 value indicating what conduit,\\n * if any, to source the fulfiller's token\\n * approvals from. The zero hash signifies\\n * that no conduit should be used, with\\n * direct approvals set on this contract.\\n * @param recipient The intended recipient for all received\\n * items, with `address(0)` indicating that\\n * the caller should receive the items.\\n * @param maximumFulfilled The maximum number of orders to fulfill.\\n *\\n * @return availableOrders An array of booleans indicating if each order\\n * with an index corresponding to the index of the\\n * returned boolean was fulfillable or not.\\n * @return executions An array of elements indicating the sequence of\\n * transfers performed as part of matching the given\\n * orders.\\n */\\n function fulfillAvailableAdvancedOrders(\\n AdvancedOrder[] calldata advancedOrders,\\n CriteriaResolver[] calldata criteriaResolvers,\\n FulfillmentComponent[][] calldata offerFulfillments,\\n FulfillmentComponent[][] calldata considerationFulfillments,\\n bytes32 fulfillerConduitKey,\\n address recipient,\\n uint256 maximumFulfilled\\n )\\n external\\n payable\\n returns (bool[] memory availableOrders, Execution[] memory executions);\\n\\n /**\\n * @notice Match an arbitrary number of orders, each with an arbitrary\\n * number of items for offer and consideration along with as set of\\n * fulfillments allocating offer components to consideration\\n * components. Note that this function does not support\\n * criteria-based or partial filling of orders (though filling the\\n * remainder of a partially-filled order is supported).\\n *\\n * @param orders The orders to match. Note that both the offerer and\\n * fulfiller on each order must first approve this\\n * contract (or their conduit if indicated by the order)\\n * to transfer any relevant tokens on their behalf and\\n * each consideration recipient must implement\\n * `onERC1155Received` to enable ERC1155 token receipt.\\n * @param fulfillments An array of elements allocating offer components to\\n * consideration components. Note that each\\n * consideration component must be fully met for the\\n * match operation to be valid.\\n *\\n * @return executions An array of elements indicating the sequence of\\n * transfers performed as part of matching the given\\n * orders.\\n */\\n function matchOrders(\\n Order[] calldata orders,\\n Fulfillment[] calldata fulfillments\\n ) external payable returns (Execution[] memory executions);\\n\\n /**\\n * @notice Match an arbitrary number of full or partial orders, each with an\\n * arbitrary number of items for offer and consideration, supplying\\n * criteria resolvers containing specific token identifiers and\\n * associated proofs as well as fulfillments allocating offer\\n * components to consideration components.\\n *\\n * @param orders The advanced orders to match. Note that both the\\n * offerer and fulfiller on each order must first\\n * approve this contract (or a preferred conduit if\\n * indicated by the order) to transfer any relevant\\n * tokens on their behalf and each consideration\\n * recipient must implement `onERC1155Received` in\\n * order to receive ERC1155 tokens. Also note that\\n * the offer and consideration components for each\\n * order must have no remainder after multiplying\\n * the respective amount with the supplied fraction\\n * in order for the group of partial fills to be\\n * considered valid.\\n * @param criteriaResolvers An array where each element contains a reference\\n * to a specific order as well as that order's\\n * offer or consideration, a token identifier, and\\n * a proof that the supplied token identifier is\\n * contained in the order's merkle root. Note that\\n * an empty root indicates that any (transferable)\\n * token identifier is valid and that no associated\\n * proof needs to be supplied.\\n * @param fulfillments An array of elements allocating offer components\\n * to consideration components. Note that each\\n * consideration component must be fully met in\\n * order for the match operation to be valid.\\n *\\n * @return executions An array of elements indicating the sequence of\\n * transfers performed as part of matching the given\\n * orders.\\n */\\n function matchAdvancedOrders(\\n AdvancedOrder[] calldata orders,\\n CriteriaResolver[] calldata criteriaResolvers,\\n Fulfillment[] calldata fulfillments\\n ) external payable returns (Execution[] memory executions);\\n\\n /**\\n * @notice Cancel an arbitrary number of orders. Note that only the offerer\\n * or the zone of a given order may cancel it. Callers should ensure\\n * that the intended order was cancelled by calling `getOrderStatus`\\n * and confirming that `isCancelled` returns `true`.\\n *\\n * @param orders The orders to cancel.\\n *\\n * @return cancelled A boolean indicating whether the supplied orders have\\n * been successfully cancelled.\\n */\\n function cancel(OrderComponents[] calldata orders)\\n external\\n returns (bool cancelled);\\n\\n /**\\n * @notice Validate an arbitrary number of orders, thereby registering their\\n * signatures as valid and allowing the fulfiller to skip signature\\n * verification on fulfillment. Note that validated orders may still\\n * be unfulfillable due to invalid item amounts or other factors;\\n * callers should determine whether validated orders are fulfillable\\n * by simulating the fulfillment call prior to execution. Also note\\n * that anyone can validate a signed order, but only the offerer can\\n * validate an order without supplying a signature.\\n *\\n * @param orders The orders to validate.\\n *\\n * @return validated A boolean indicating whether the supplied orders have\\n * been successfully validated.\\n */\\n function validate(Order[] calldata orders)\\n external\\n returns (bool validated);\\n\\n /**\\n * @notice Cancel all orders from a given offerer with a given zone in bulk\\n * by incrementing a counter. Note that only the offerer may\\n * increment the counter.\\n *\\n * @return newCounter The new counter.\\n */\\n function incrementCounter() external returns (uint256 newCounter);\\n\\n /**\\n * @notice Retrieve the order hash for a given order.\\n *\\n * @param order The components of the order.\\n *\\n * @return orderHash The order hash.\\n */\\n function getOrderHash(OrderComponents calldata order)\\n external\\n view\\n returns (bytes32 orderHash);\\n\\n /**\\n * @notice Retrieve the status of a given order by hash, including whether\\n * the order has been cancelled or validated and the fraction of the\\n * order that has been filled.\\n *\\n * @param orderHash The order hash in question.\\n *\\n * @return isValidated A boolean indicating whether the order in question\\n * has been validated (i.e. previously approved or\\n * partially filled).\\n * @return isCancelled A boolean indicating whether the order in question\\n * has been cancelled.\\n * @return totalFilled The total portion of the order that has been filled\\n * (i.e. the \\\"numerator\\\").\\n * @return totalSize The total size of the order that is either filled or\\n * unfilled (i.e. the \\\"denominator\\\").\\n */\\n function getOrderStatus(bytes32 orderHash)\\n external\\n view\\n returns (\\n bool isValidated,\\n bool isCancelled,\\n uint256 totalFilled,\\n uint256 totalSize\\n );\\n\\n /**\\n * @notice Retrieve the current counter for a given offerer.\\n *\\n * @param offerer The offerer in question.\\n *\\n * @return counter The current counter.\\n */\\n function getCounter(address offerer)\\n external\\n view\\n returns (uint256 counter);\\n\\n /**\\n * @notice Retrieve configuration information for this contract.\\n *\\n * @return version The contract version.\\n * @return domainSeparator The domain separator for this contract.\\n * @return conduitController The conduit Controller set for this contract.\\n */\\n function information()\\n external\\n view\\n returns (\\n string memory version,\\n bytes32 domainSeparator,\\n address conduitController\\n );\\n\\n /**\\n * @notice Retrieve the name of this contract.\\n *\\n * @return contractName The name of this contract.\\n */\\n function name() external view returns (string memory contractName);\\n}\\n\",\"keccak256\":\"0x29ac4547e5437dcd2f8a6415d4f18045e6f0da3f88ecf53c5c334b060dbede46\",\"license\":\"MIT\"},\"contracts/interfaces/CriteriaResolutionErrors.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.7;\\n\\n/**\\n * @title CriteriaResolutionErrors\\n * @author 0age\\n * @notice CriteriaResolutionErrors contains all errors related to criteria\\n * resolution.\\n */\\ninterface CriteriaResolutionErrors {\\n /**\\n * @dev Revert with an error when providing a criteria resolver that refers\\n * to an order that has not been supplied.\\n */\\n error OrderCriteriaResolverOutOfRange();\\n\\n /**\\n * @dev Revert with an error if an offer item still has unresolved criteria\\n * after applying all criteria resolvers.\\n */\\n error UnresolvedOfferCriteria();\\n\\n /**\\n * @dev Revert with an error if a consideration item still has unresolved\\n * criteria after applying all criteria resolvers.\\n */\\n error UnresolvedConsiderationCriteria();\\n\\n /**\\n * @dev Revert with an error when providing a criteria resolver that refers\\n * to an order with an offer item that has not been supplied.\\n */\\n error OfferCriteriaResolverOutOfRange();\\n\\n /**\\n * @dev Revert with an error when providing a criteria resolver that refers\\n * to an order with a consideration item that has not been supplied.\\n */\\n error ConsiderationCriteriaResolverOutOfRange();\\n\\n /**\\n * @dev Revert with an error when providing a criteria resolver that refers\\n * to an order with an item that does not expect a criteria to be\\n * resolved.\\n */\\n error CriteriaNotEnabledForItem();\\n\\n /**\\n * @dev Revert with an error when providing a criteria resolver that\\n * contains an invalid proof with respect to the given item and\\n * chosen identifier.\\n */\\n error InvalidProof();\\n}\\n\",\"keccak256\":\"0x3c63de591ecf89478714308c38953d72b88c7034f9b4ae4605f356a121df969e\",\"license\":\"MIT\"},\"contracts/interfaces/EIP1271Interface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.7;\\n\\ninterface EIP1271Interface {\\n function isValidSignature(bytes32 digest, bytes calldata signature)\\n external\\n view\\n returns (bytes4);\\n}\\n\",\"keccak256\":\"0x3c60fdc09b2bc7cb3a615ca82ee1bd776813e75883515efd1e794fe8a3228f29\",\"license\":\"MIT\"},\"contracts/interfaces/FulfillmentApplicationErrors.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.7;\\n\\nimport { Side } from \\\"../lib/ConsiderationEnums.sol\\\";\\n\\n/**\\n * @title FulfillmentApplicationErrors\\n * @author 0age\\n * @notice FulfillmentApplicationErrors contains errors related to fulfillment\\n * application and aggregation.\\n */\\ninterface FulfillmentApplicationErrors {\\n /**\\n * @dev Revert with an error when a fulfillment is provided that does not\\n * declare at least one component as part of a call to fulfill\\n * available orders.\\n */\\n error MissingFulfillmentComponentOnAggregation(Side side);\\n\\n /**\\n * @dev Revert with an error when a fulfillment is provided that does not\\n * declare at least one offer component and at least one consideration\\n * component.\\n */\\n error OfferAndConsiderationRequiredOnFulfillment();\\n\\n /**\\n * @dev Revert with an error when the initial offer item named by a\\n * fulfillment component does not match the type, token, identifier,\\n * or conduit preference of the initial consideration item.\\n */\\n error MismatchedFulfillmentOfferAndConsiderationComponents();\\n\\n /**\\n * @dev Revert with an error when an order or item index are out of range\\n * or a fulfillment component does not match the type, token,\\n * identifier, or conduit preference of the initial consideration item.\\n */\\n error InvalidFulfillmentComponentData();\\n}\\n\",\"keccak256\":\"0x4d66a660feba521d6cedd1677c3178e405a8414700401f5f5487179b8c8016df\",\"license\":\"MIT\"},\"contracts/interfaces/ReentrancyErrors.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.7;\\n\\n/**\\n * @title ReentrancyErrors\\n * @author 0age\\n * @notice ReentrancyErrors contains errors related to reentrancy.\\n */\\ninterface ReentrancyErrors {\\n /**\\n * @dev Revert with an error when a caller attempts to reenter a protected\\n * function.\\n */\\n error NoReentrantCalls();\\n}\\n\",\"keccak256\":\"0x9ab27fa5a68f55ad89072ea213c6f12979ae469041ca473d81f800dbdbe9bb48\",\"license\":\"MIT\"},\"contracts/interfaces/SignatureVerificationErrors.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.7;\\n\\n/**\\n * @title SignatureVerificationErrors\\n * @author 0age\\n * @notice SignatureVerificationErrors contains all errors related to signature\\n * verification.\\n */\\ninterface SignatureVerificationErrors {\\n /**\\n * @dev Revert with an error when a signature that does not contain a v\\n * value of 27 or 28 has been supplied.\\n *\\n * @param v The invalid v value.\\n */\\n error BadSignatureV(uint8 v);\\n\\n /**\\n * @dev Revert with an error when the signer recovered by the supplied\\n * signature does not match the offerer or an allowed EIP-1271 signer\\n * as specified by the offerer in the event they are a contract.\\n */\\n error InvalidSigner();\\n\\n /**\\n * @dev Revert with an error when a signer cannot be recovered from the\\n * supplied signature.\\n */\\n error InvalidSignature();\\n\\n /**\\n * @dev Revert with an error when an EIP-1271 call to an account fails.\\n */\\n error BadContractSignature();\\n}\\n\",\"keccak256\":\"0xb86f318b159c16087372e12b1e2c37c15fb745be1566bb03812e3814c15fb605\",\"license\":\"MIT\"},\"contracts/interfaces/TokenTransferrerErrors.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.7;\\n\\n/**\\n * @title TokenTransferrerErrors\\n */\\ninterface TokenTransferrerErrors {\\n /**\\n * @dev Revert with an error when an ERC721 transfer with amount other than\\n * one is attempted.\\n */\\n error InvalidERC721TransferAmount();\\n\\n /**\\n * @dev Revert with an error when attempting to fulfill an order where an\\n * item has an amount of zero.\\n */\\n error MissingItemAmount();\\n\\n /**\\n * @dev Revert with an error when attempting to fulfill an order where an\\n * item has unused parameters. This includes both the token and the\\n * identifier parameters for native transfers as well as the identifier\\n * parameter for ERC20 transfers. Note that the conduit does not\\n * perform this check, leaving it up to the calling channel to enforce\\n * when desired.\\n */\\n error UnusedItemParameters();\\n\\n /**\\n * @dev Revert with an error when an ERC20, ERC721, or ERC1155 token\\n * transfer reverts.\\n *\\n * @param token The token for which the transfer was attempted.\\n * @param from The source of the attempted transfer.\\n * @param to The recipient of the attempted transfer.\\n * @param identifier The identifier for the attempted transfer.\\n * @param amount The amount for the attempted transfer.\\n */\\n error TokenTransferGenericFailure(\\n address token,\\n address from,\\n address to,\\n uint256 identifier,\\n uint256 amount\\n );\\n\\n /**\\n * @dev Revert with an error when a batch ERC1155 token transfer reverts.\\n *\\n * @param token The token for which the transfer was attempted.\\n * @param from The source of the attempted transfer.\\n * @param to The recipient of the attempted transfer.\\n * @param identifiers The identifiers for the attempted transfer.\\n * @param amounts The amounts for the attempted transfer.\\n */\\n error ERC1155BatchTransferGenericFailure(\\n address token,\\n address from,\\n address to,\\n uint256[] identifiers,\\n uint256[] amounts\\n );\\n\\n /**\\n * @dev Revert with an error when an ERC20 token transfer returns a falsey\\n * value.\\n *\\n * @param token The token for which the ERC20 transfer was attempted.\\n * @param from The source of the attempted ERC20 transfer.\\n * @param to The recipient of the attempted ERC20 transfer.\\n * @param amount The amount for the attempted ERC20 transfer.\\n */\\n error BadReturnValueFromERC20OnTransfer(\\n address token,\\n address from,\\n address to,\\n uint256 amount\\n );\\n\\n /**\\n * @dev Revert with an error when an account being called as an assumed\\n * contract does not have code and returns no data.\\n *\\n * @param account The account that should contain code.\\n */\\n error NoContract(address account);\\n\\n /**\\n * @dev Revert with an error when attempting to execute an 1155 batch\\n * transfer using calldata not produced by default ABI encoding or with\\n * different lengths for ids and amounts arrays.\\n */\\n error Invalid1155BatchTransferEncoding();\\n}\\n\",\"keccak256\":\"0xd547a837e72da776edb433ef6bbb5ab1dbf4bc8e98995ca2baf83edcadd73607\",\"license\":\"MIT\"},\"contracts/interfaces/ZoneInteractionErrors.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.7;\\n\\n/**\\n * @title ZoneInteractionErrors\\n * @author 0age\\n * @notice ZoneInteractionErrors contains errors related to zone interaction.\\n */\\ninterface ZoneInteractionErrors {\\n /**\\n * @dev Revert with an error when attempting to fill an order that specifies\\n * a restricted submitter as its order type when not submitted by\\n * either the offerer or the order's zone or approved as valid by the\\n * zone in question via a staticcall to `isValidOrder`.\\n *\\n * @param orderHash The order hash for the invalid restricted order.\\n */\\n error InvalidRestrictedOrder(bytes32 orderHash);\\n}\\n\",\"keccak256\":\"0x4de0f0c7964a11f06baed4b751a99b18dcae95ffdc18fe9918c0fdf53db994da\",\"license\":\"MIT\"},\"contracts/interfaces/ZoneInterface.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.7;\\n\\n// prettier-ignore\\nimport {\\n AdvancedOrder,\\n CriteriaResolver\\n} from \\\"../lib/ConsiderationStructs.sol\\\";\\n\\ninterface ZoneInterface {\\n // Called by Consideration whenever extraData is not provided by the caller.\\n function isValidOrder(\\n bytes32 orderHash,\\n address caller,\\n address offerer,\\n bytes32 zoneHash\\n ) external view returns (bytes4 validOrderMagicValue);\\n\\n // Called by Consideration whenever any extraData is provided by the caller.\\n function isValidOrderIncludingExtraData(\\n bytes32 orderHash,\\n address caller,\\n AdvancedOrder calldata order,\\n bytes32[] calldata priorOrderHashes,\\n CriteriaResolver[] calldata criteriaResolvers\\n ) external view returns (bytes4 validOrderMagicValue);\\n}\\n\",\"keccak256\":\"0x5c5d749fd3de01bd89acf7cb08f11d041b3a600819e18b8a51cebd65285ced46\",\"license\":\"MIT\"},\"contracts/lib/AmountDeriver.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.13;\\n\\n// prettier-ignore\\nimport {\\n AmountDerivationErrors\\n} from \\\"../interfaces/AmountDerivationErrors.sol\\\";\\n\\nimport \\\"./ConsiderationConstants.sol\\\";\\n\\n/**\\n * @title AmountDeriver\\n * @author 0age\\n * @notice AmountDeriver contains view and pure functions related to deriving\\n * item amounts based on partial fill quantity and on linear\\n * interpolation based on current time when the start amount and end\\n * amount differ.\\n */\\ncontract AmountDeriver is AmountDerivationErrors {\\n /**\\n * @dev Internal view function to derive the current amount of a given item\\n * based on the current price, the starting price, and the ending\\n * price. If the start and end prices differ, the current price will be\\n * interpolated on a linear basis. Note that this function expects that\\n * the startTime parameter of orderParameters is not greater than the\\n * current block timestamp and that the endTime parameter is greater\\n * than the current block timestamp. If this condition is not upheld,\\n * duration / elapsed / remaining variables will underflow.\\n *\\n * @param startAmount The starting amount of the item.\\n * @param endAmount The ending amount of the item.\\n * @param startTime The starting time of the order.\\n * @param endTime The end time of the order.\\n * @param roundUp A boolean indicating whether the resultant amount\\n * should be rounded up or down.\\n *\\n * @return amount The current amount.\\n */\\n function _locateCurrentAmount(\\n uint256 startAmount,\\n uint256 endAmount,\\n uint256 startTime,\\n uint256 endTime,\\n bool roundUp\\n ) internal view returns (uint256 amount) {\\n // Only modify end amount if it doesn't already equal start amount.\\n if (startAmount != endAmount) {\\n // Declare variables to derive in the subsequent unchecked scope.\\n uint256 duration;\\n uint256 elapsed;\\n uint256 remaining;\\n\\n // Skip underflow checks as startTime <= block.timestamp < endTime.\\n unchecked {\\n // Derive the duration for the order and place it on the stack.\\n duration = endTime - startTime;\\n\\n // Derive time elapsed since the order started & place on stack.\\n elapsed = block.timestamp - startTime;\\n\\n // Derive time remaining until order expires and place on stack.\\n remaining = duration - elapsed;\\n }\\n\\n // Aggregate new amounts weighted by time with rounding factor.\\n uint256 totalBeforeDivision = ((startAmount * remaining) +\\n (endAmount * elapsed));\\n\\n // Use assembly to combine operations and skip divide-by-zero check.\\n assembly {\\n // Multiply by iszero(iszero(totalBeforeDivision)) to ensure\\n // amount is set to zero if totalBeforeDivision is zero,\\n // as intermediate overflow can occur if it is zero.\\n amount := mul(\\n iszero(iszero(totalBeforeDivision)),\\n // Subtract 1 from the numerator and add 1 to the result if\\n // roundUp is true to get the proper rounding direction.\\n // Division is performed with no zero check as duration\\n // cannot be zero as long as startTime < endTime.\\n add(\\n div(sub(totalBeforeDivision, roundUp), duration),\\n roundUp\\n )\\n )\\n }\\n\\n // Return the current amount.\\n return amount;\\n }\\n\\n // Return the original amount as startAmount == endAmount.\\n return endAmount;\\n }\\n\\n /**\\n * @dev Internal pure function to return a fraction of a given value and to\\n * ensure the resultant value does not have any fractional component.\\n * Note that this function assumes that zero will never be supplied as\\n * the denominator parameter; invalid / undefined behavior will result\\n * should a denominator of zero be provided.\\n *\\n * @param numerator A value indicating the portion of the order that\\n * should be filled.\\n * @param denominator A value indicating the total size of the order. Note\\n * that this value cannot be equal to zero.\\n * @param value The value for which to compute the fraction.\\n *\\n * @return newValue The value after applying the fraction.\\n */\\n function _getFraction(\\n uint256 numerator,\\n uint256 denominator,\\n uint256 value\\n ) internal pure returns (uint256 newValue) {\\n // Return value early in cases where the fraction resolves to 1.\\n if (numerator == denominator) {\\n return value;\\n }\\n\\n // Ensure fraction can be applied to the value with no remainder. Note\\n // that the denominator cannot be zero.\\n assembly {\\n // Ensure new value contains no remainder via mulmod operator.\\n // Credit to @hrkrshnn + @axic for proposing this optimal solution.\\n if mulmod(value, numerator, denominator) {\\n mstore(0, InexactFraction_error_signature)\\n revert(0, InexactFraction_error_len)\\n }\\n }\\n\\n // Multiply the numerator by the value and ensure no overflow occurs.\\n uint256 valueTimesNumerator = value * numerator;\\n\\n // Divide and check for remainder. Note that denominator cannot be zero.\\n assembly {\\n // Perform division without zero check.\\n newValue := div(valueTimesNumerator, denominator)\\n }\\n }\\n\\n /**\\n * @dev Internal view function to apply a fraction to a consideration\\n * or offer item.\\n *\\n * @param startAmount The starting amount of the item.\\n * @param endAmount The ending amount of the item.\\n * @param numerator A value indicating the portion of the order that\\n * should be filled.\\n * @param denominator A value indicating the total size of the order.\\n * @param startTime The starting time of the order.\\n * @param endTime The end time of the order.\\n * @param roundUp A boolean indicating whether the resultant\\n * amount should be rounded up or down.\\n *\\n * @return amount The received item to transfer with the final amount.\\n */\\n function _applyFraction(\\n uint256 startAmount,\\n uint256 endAmount,\\n uint256 numerator,\\n uint256 denominator,\\n uint256 startTime,\\n uint256 endTime,\\n bool roundUp\\n ) internal view returns (uint256 amount) {\\n // If start amount equals end amount, apply fraction to end amount.\\n if (startAmount == endAmount) {\\n // Apply fraction to end amount.\\n amount = _getFraction(numerator, denominator, endAmount);\\n } else {\\n // Otherwise, apply fraction to both and interpolated final amount.\\n amount = _locateCurrentAmount(\\n _getFraction(numerator, denominator, startAmount),\\n _getFraction(numerator, denominator, endAmount),\\n startTime,\\n endTime,\\n roundUp\\n );\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0a1b7661b18351ae1570a0ff76444b3dfc4c0034c75e7b49d5e72836bd1caa79\",\"license\":\"MIT\"},\"contracts/lib/Assertions.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.13;\\n\\nimport { OrderParameters } from \\\"./ConsiderationStructs.sol\\\";\\n\\nimport { GettersAndDerivers } from \\\"./GettersAndDerivers.sol\\\";\\n\\n// prettier-ignore\\nimport {\\n TokenTransferrerErrors\\n} from \\\"../interfaces/TokenTransferrerErrors.sol\\\";\\n\\nimport { CounterManager } from \\\"./CounterManager.sol\\\";\\n\\nimport \\\"./ConsiderationConstants.sol\\\";\\n\\n/**\\n * @title Assertions\\n * @author 0age\\n * @notice Assertions contains logic for making various assertions that do not\\n * fit neatly within a dedicated semantic scope.\\n */\\ncontract Assertions is\\n GettersAndDerivers,\\n CounterManager,\\n TokenTransferrerErrors\\n{\\n /**\\n * @dev Derive and set hashes, reference chainId, and associated domain\\n * separator during deployment.\\n *\\n * @param conduitController A contract that deploys conduits, or proxies\\n * that may optionally be used to transfer approved\\n * ERC20/721/1155 tokens.\\n */\\n constructor(address conduitController)\\n GettersAndDerivers(conduitController)\\n {}\\n\\n /**\\n * @dev Internal view function to ensure that the supplied consideration\\n * array length on a given set of order parameters is not less than the\\n * original consideration array length for that order and to retrieve\\n * the current counter for a given order's offerer and zone and use it\\n * to derive the order hash.\\n *\\n * @param orderParameters The parameters of the order to hash.\\n *\\n * @return The hash.\\n */\\n function _assertConsiderationLengthAndGetOrderHash(\\n OrderParameters memory orderParameters\\n ) internal view returns (bytes32) {\\n // Ensure supplied consideration array length is not less than original.\\n _assertConsiderationLengthIsNotLessThanOriginalConsiderationLength(\\n orderParameters.consideration.length,\\n orderParameters.totalOriginalConsiderationItems\\n );\\n\\n // Derive and return order hash using current counter for the offerer.\\n return\\n _deriveOrderHash(\\n orderParameters,\\n _getCounter(orderParameters.offerer)\\n );\\n }\\n\\n /**\\n * @dev Internal pure function to ensure that the supplied consideration\\n * array length for an order to be fulfilled is not less than the\\n * original consideration array length for that order.\\n *\\n * @param suppliedConsiderationItemTotal The number of consideration items\\n * supplied when fulfilling the order.\\n * @param originalConsiderationItemTotal The number of consideration items\\n * supplied on initial order creation.\\n */\\n function _assertConsiderationLengthIsNotLessThanOriginalConsiderationLength(\\n uint256 suppliedConsiderationItemTotal,\\n uint256 originalConsiderationItemTotal\\n ) internal pure {\\n // Ensure supplied consideration array length is not less than original.\\n if (suppliedConsiderationItemTotal < originalConsiderationItemTotal) {\\n revert MissingOriginalConsiderationItems();\\n }\\n }\\n\\n /**\\n * @dev Internal pure function to ensure that a given item amount is not\\n * zero.\\n *\\n * @param amount The amount to check.\\n */\\n function _assertNonZeroAmount(uint256 amount) internal pure {\\n // Revert if the supplied amount is equal to zero.\\n if (amount == 0) {\\n revert MissingItemAmount();\\n }\\n }\\n\\n /**\\n * @dev Internal pure function to validate calldata offsets for dynamic\\n * types in BasicOrderParameters and other parameters. This ensures\\n * that functions using the calldata object normally will be using the\\n * same data as the assembly functions and that values that are bound\\n * to a given range are within that range. Note that no parameters are\\n * supplied as all basic order functions use the same calldata\\n * encoding.\\n */\\n function _assertValidBasicOrderParameters() internal pure {\\n // Declare a boolean designating basic order parameter offset validity.\\n bool validOffsets;\\n\\n // Utilize assembly in order to read offset data directly from calldata.\\n assembly {\\n /*\\n * Checks:\\n * 1. Order parameters struct offset == 0x20\\n * 2. Additional recipients arr offset == 0x240\\n * 3. Signature offset == 0x260 + (recipients.length * 0x40)\\n * 4. BasicOrderType between 0 and 23 (i.e. < 24)\\n */\\n validOffsets := and(\\n // Order parameters at calldata 0x04 must have offset of 0x20.\\n eq(\\n calldataload(BasicOrder_parameters_cdPtr),\\n BasicOrder_parameters_ptr\\n ),\\n // Additional recipients at cd 0x224 must have offset of 0x240.\\n eq(\\n calldataload(BasicOrder_additionalRecipients_head_cdPtr),\\n BasicOrder_additionalRecipients_head_ptr\\n )\\n )\\n\\n validOffsets := and(\\n validOffsets,\\n eq(\\n // Load signature offset from calldata 0x244.\\n calldataload(BasicOrder_signature_cdPtr),\\n // Derive expected offset as start of recipients + len * 64.\\n add(\\n BasicOrder_signature_ptr,\\n mul(\\n // Additional recipients length at calldata 0x264.\\n calldataload(\\n BasicOrder_additionalRecipients_length_cdPtr\\n ),\\n // Each additional recipient has a length of 0x40.\\n AdditionalRecipients_size\\n )\\n )\\n )\\n )\\n\\n validOffsets := and(\\n validOffsets,\\n lt(\\n // BasicOrderType parameter at calldata offset 0x124.\\n calldataload(BasicOrder_basicOrderType_cdPtr),\\n // Value should be less than 24.\\n BasicOrder_basicOrderType_range\\n )\\n )\\n }\\n\\n // Revert with an error if basic order parameter offsets are invalid.\\n if (!validOffsets) {\\n revert InvalidBasicOrderParameterEncoding();\\n }\\n }\\n}\\n\",\"keccak256\":\"0x47d94e2a244292b20e5a854350cdbb37839f7a54a349ea78f8543910501cae9e\",\"license\":\"MIT\"},\"contracts/lib/BasicOrderFulfiller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.13;\\n\\nimport { ConduitInterface } from \\\"../interfaces/ConduitInterface.sol\\\";\\n\\n// prettier-ignore\\nimport {\\n OrderType,\\n ItemType,\\n BasicOrderRouteType\\n} from \\\"./ConsiderationEnums.sol\\\";\\n\\n// prettier-ignore\\nimport {\\n AdditionalRecipient,\\n BasicOrderParameters,\\n OfferItem,\\n ConsiderationItem,\\n SpentItem,\\n ReceivedItem\\n} from \\\"./ConsiderationStructs.sol\\\";\\n\\nimport { OrderValidator } from \\\"./OrderValidator.sol\\\";\\n\\nimport \\\"./ConsiderationConstants.sol\\\";\\n\\n/**\\n * @title BasicOrderFulfiller\\n * @author 0age\\n * @notice BasicOrderFulfiller contains functionality for fulfilling \\\"basic\\\"\\n * orders with minimal overhead. See documentation for details on what\\n * qualifies as a basic order.\\n */\\ncontract BasicOrderFulfiller is OrderValidator {\\n /**\\n * @dev Derive and set hashes, reference chainId, and associated domain\\n * separator during deployment.\\n *\\n * @param conduitController A contract that deploys conduits, or proxies\\n * that may optionally be used to transfer approved\\n * ERC20/721/1155 tokens.\\n */\\n constructor(address conduitController) OrderValidator(conduitController) {}\\n\\n /**\\n * @dev Internal function to fulfill an order offering an ERC20, ERC721, or\\n * ERC1155 item by supplying Ether (or other native tokens), ERC20\\n * tokens, an ERC721 item, or an ERC1155 item as consideration. Six\\n * permutations are supported: Native token to ERC721, Native token to\\n * ERC1155, ERC20 to ERC721, ERC20 to ERC1155, ERC721 to ERC20, and\\n * ERC1155 to ERC20 (with native tokens supplied as msg.value). For an\\n * order to be eligible for fulfillment via this method, it must\\n * contain a single offer item (though that item may have a greater\\n * amount if the item is not an ERC721). An arbitrary number of\\n * \\\"additional recipients\\\" may also be supplied which will each receive\\n * native tokens or ERC20 items from the fulfiller as consideration.\\n * Refer to the documentation for a more comprehensive summary of how\\n * to utilize this method and what orders are compatible with it.\\n *\\n * @param parameters Additional information on the fulfilled order. Note\\n * that the offerer and the fulfiller must first approve\\n * this contract (or their chosen conduit if indicated)\\n * before any tokens can be transferred. Also note that\\n * contract recipients of ERC1155 consideration items must\\n * implement `onERC1155Received` in order to receive those\\n * items.\\n *\\n * @return A boolean indicating whether the order has been fulfilled.\\n */\\n function _validateAndFulfillBasicOrder(\\n BasicOrderParameters calldata parameters\\n ) internal returns (bool) {\\n // Declare enums for order type & route to extract from basicOrderType.\\n BasicOrderRouteType route;\\n OrderType orderType;\\n\\n // Declare additional recipient item type to derive from the route type.\\n ItemType additionalRecipientsItemType;\\n\\n // Utilize assembly to extract the order type and the basic order route.\\n assembly {\\n // Read basicOrderType from calldata.\\n let basicOrderType := calldataload(BasicOrder_basicOrderType_cdPtr)\\n\\n // Mask all but 2 least-significant bits to derive the order type.\\n orderType := and(basicOrderType, 3)\\n\\n // Divide basicOrderType by four to derive the route.\\n route := shr(2, basicOrderType)\\n\\n // If route > 1 additionalRecipient items are ERC20 (1) else Eth (0)\\n additionalRecipientsItemType := gt(route, 1)\\n }\\n\\n {\\n // Declare temporary variable for enforcing payable status.\\n bool correctPayableStatus;\\n\\n // Utilize assembly to compare the route to the callvalue.\\n assembly {\\n // route 0 and 1 are payable, otherwise route is not payable.\\n correctPayableStatus := eq(\\n additionalRecipientsItemType,\\n iszero(callvalue())\\n )\\n }\\n\\n // Revert if msg.value has not been supplied as part of payable\\n // routes or has been supplied as part of non-payable routes.\\n if (!correctPayableStatus) {\\n revert InvalidMsgValue(msg.value);\\n }\\n }\\n\\n // Declare more arguments that will be derived from route and calldata.\\n address additionalRecipientsToken;\\n ItemType offeredItemType;\\n bool offerTypeIsAdditionalRecipientsType;\\n\\n // Declare scope for received item type to manage stack pressure.\\n {\\n ItemType receivedItemType;\\n\\n // Utilize assembly to retrieve function arguments and cast types.\\n assembly {\\n // Check if offered item type == additional recipient item type.\\n offerTypeIsAdditionalRecipientsType := gt(route, 3)\\n\\n // If route > 3 additionalRecipientsToken is at 0xc4 else 0x24.\\n additionalRecipientsToken := calldataload(\\n add(\\n BasicOrder_considerationToken_cdPtr,\\n mul(\\n offerTypeIsAdditionalRecipientsType,\\n BasicOrder_common_params_size\\n )\\n )\\n )\\n\\n // If route > 2, receivedItemType is route - 2. If route is 2,\\n // the receivedItemType is ERC20 (1). Otherwise, it is Eth (0).\\n receivedItemType := add(\\n mul(sub(route, 2), gt(route, 2)),\\n eq(route, 2)\\n )\\n\\n // If route > 3, offeredItemType is ERC20 (1). Route is 2 or 3,\\n // offeredItemType = route. Route is 0 or 1, it is route + 2.\\n offeredItemType := sub(\\n add(route, mul(iszero(additionalRecipientsItemType), 2)),\\n mul(\\n offerTypeIsAdditionalRecipientsType,\\n add(receivedItemType, 1)\\n )\\n )\\n }\\n\\n // Derive & validate order using parameters and update order status.\\n _prepareBasicFulfillmentFromCalldata(\\n parameters,\\n orderType,\\n receivedItemType,\\n additionalRecipientsItemType,\\n additionalRecipientsToken,\\n offeredItemType\\n );\\n }\\n\\n // Declare conduitKey argument used by transfer functions.\\n bytes32 conduitKey;\\n\\n // Utilize assembly to derive conduit (if relevant) based on route.\\n assembly {\\n // use offerer conduit for routes 0-3, fulfiller conduit otherwise.\\n conduitKey := calldataload(\\n add(\\n BasicOrder_offererConduit_cdPtr,\\n mul(offerTypeIsAdditionalRecipientsType, OneWord)\\n )\\n )\\n }\\n\\n // Transfer tokens based on the route.\\n if (additionalRecipientsItemType == ItemType.NATIVE) {\\n // Ensure neither the token nor the identifier parameters are set.\\n if (\\n (uint160(parameters.considerationToken) |\\n parameters.considerationIdentifier) != 0\\n ) {\\n revert UnusedItemParameters();\\n }\\n\\n // Transfer the ERC721 or ERC1155 item, bypassing the accumulator.\\n _transferIndividual721Or1155Item(\\n offeredItemType,\\n parameters.offerToken,\\n parameters.offerer,\\n msg.sender,\\n parameters.offerIdentifier,\\n parameters.offerAmount,\\n conduitKey\\n );\\n\\n // Transfer native to recipients, return excess to caller & wrap up.\\n _transferEthAndFinalize(\\n parameters.considerationAmount,\\n parameters.offerer,\\n parameters.additionalRecipients\\n );\\n } else {\\n // Initialize an accumulator array. From this point forward, no new\\n // memory regions can be safely allocated until the accumulator is\\n // no longer being utilized, as the accumulator operates in an\\n // open-ended fashion from this memory pointer; existing memory may\\n // still be accessed and modified, however.\\n bytes memory accumulator = new bytes(AccumulatorDisarmed);\\n\\n // Choose transfer method for ERC721 or ERC1155 item based on route.\\n if (route == BasicOrderRouteType.ERC20_TO_ERC721) {\\n // Transfer ERC721 to caller using offerer's conduit preference.\\n _transferERC721(\\n parameters.offerToken,\\n parameters.offerer,\\n msg.sender,\\n parameters.offerIdentifier,\\n parameters.offerAmount,\\n conduitKey,\\n accumulator\\n );\\n } else if (route == BasicOrderRouteType.ERC20_TO_ERC1155) {\\n // Transfer ERC1155 to caller with offerer's conduit preference.\\n _transferERC1155(\\n parameters.offerToken,\\n parameters.offerer,\\n msg.sender,\\n parameters.offerIdentifier,\\n parameters.offerAmount,\\n conduitKey,\\n accumulator\\n );\\n } else if (route == BasicOrderRouteType.ERC721_TO_ERC20) {\\n // Transfer ERC721 to offerer using caller's conduit preference.\\n _transferERC721(\\n parameters.considerationToken,\\n msg.sender,\\n parameters.offerer,\\n parameters.considerationIdentifier,\\n parameters.considerationAmount,\\n conduitKey,\\n accumulator\\n );\\n } else {\\n // route == BasicOrderRouteType.ERC1155_TO_ERC20\\n\\n // Transfer ERC1155 to offerer with caller's conduit preference.\\n _transferERC1155(\\n parameters.considerationToken,\\n msg.sender,\\n parameters.offerer,\\n parameters.considerationIdentifier,\\n parameters.considerationAmount,\\n conduitKey,\\n accumulator\\n );\\n }\\n\\n // Transfer ERC20 tokens to all recipients and wrap up.\\n _transferERC20AndFinalize(\\n parameters.offerer,\\n parameters,\\n offerTypeIsAdditionalRecipientsType,\\n accumulator\\n );\\n\\n // Trigger any remaining accumulated transfers via call to conduit.\\n _triggerIfArmed(accumulator);\\n }\\n\\n // Clear the reentrancy guard.\\n _clearReentrancyGuard();\\n\\n return true;\\n }\\n\\n /**\\n * @dev Internal function to prepare fulfillment of a basic order with\\n * manual calldata and memory access. This calculates the order hash,\\n * emits an OrderFulfilled event, and asserts basic order validity.\\n * Note that calldata offsets must be validated as this function\\n * accesses constant calldata pointers for dynamic types that match\\n * default ABI encoding, but valid ABI encoding can use arbitrary\\n * offsets. Checking that the offsets were produced by default encoding\\n * will ensure that other functions using Solidity's calldata accessors\\n * (which calculate pointers from the stored offsets) are reading the\\n * same data as the order hash is derived from. Also note that This\\n * function accesses memory directly. It does not clear the expanded\\n * memory regions used, nor does it update the free memory pointer, so\\n * other direct memory access must not assume that unused memory is\\n * empty.\\n *\\n * @param parameters The parameters of the basic order.\\n * @param orderType The order type.\\n * @param receivedItemType The item type of the initial\\n * consideration item on the order.\\n * @param additionalRecipientsItemType The item type of any additional\\n * consideration item on the order.\\n * @param additionalRecipientsToken The ERC20 token contract address (if\\n * applicable) for any additional\\n * consideration item on the order.\\n * @param offeredItemType The item type of the offered item on\\n * the order.\\n */\\n function _prepareBasicFulfillmentFromCalldata(\\n BasicOrderParameters calldata parameters,\\n OrderType orderType,\\n ItemType receivedItemType,\\n ItemType additionalRecipientsItemType,\\n address additionalRecipientsToken,\\n ItemType offeredItemType\\n ) internal {\\n // Ensure this function cannot be triggered during a reentrant call.\\n _setReentrancyGuard();\\n\\n // Ensure current timestamp falls between order start time and end time.\\n _verifyTime(parameters.startTime, parameters.endTime, true);\\n\\n // Verify that calldata offsets for all dynamic types were produced by\\n // default encoding. This ensures that the constants we use for calldata\\n // pointers to dynamic types are the same as those calculated by\\n // Solidity using their offsets. Also verify that the basic order type\\n // is within range.\\n _assertValidBasicOrderParameters();\\n\\n // Ensure supplied consideration array length is not less than original.\\n _assertConsiderationLengthIsNotLessThanOriginalConsiderationLength(\\n parameters.additionalRecipients.length,\\n parameters.totalOriginalAdditionalRecipients\\n );\\n\\n // Declare stack element for the order hash.\\n bytes32 orderHash;\\n\\n {\\n /**\\n * First, handle consideration items. Memory Layout:\\n * 0x60: final hash of the array of consideration item hashes\\n * 0x80-0x160: reused space for EIP712 hashing of each item\\n * - 0x80: ConsiderationItem EIP-712 typehash (constant)\\n * - 0xa0: itemType\\n * - 0xc0: token\\n * - 0xe0: identifier\\n * - 0x100: startAmount\\n * - 0x120: endAmount\\n * - 0x140: recipient\\n * 0x160-END_ARR: array of consideration item hashes\\n * - 0x160: primary consideration item EIP712 hash\\n * - 0x180-END_ARR: additional recipient item EIP712 hashes\\n * END_ARR: beginning of data for OrderFulfilled event\\n * - END_ARR + 0x120: length of ReceivedItem array\\n * - END_ARR + 0x140: beginning of data for first ReceivedItem\\n * (Note: END_ARR = 0x180 + RECIPIENTS_LENGTH * 0x20)\\n */\\n\\n // Load consideration item typehash from runtime and place on stack.\\n bytes32 typeHash = _CONSIDERATION_ITEM_TYPEHASH;\\n\\n // Utilize assembly to enable reuse of memory regions and use\\n // constant pointers when possible.\\n assembly {\\n /*\\n * 1. Calculate the EIP712 ConsiderationItem hash for the\\n * primary consideration item of the basic order.\\n */\\n\\n // Write ConsiderationItem type hash and item type to memory.\\n mstore(BasicOrder_considerationItem_typeHash_ptr, typeHash)\\n mstore(\\n BasicOrder_considerationItem_itemType_ptr,\\n receivedItemType\\n )\\n\\n // Copy calldata region with (token, identifier, amount) from\\n // BasicOrderParameters to ConsiderationItem. The\\n // considerationAmount is written to startAmount and endAmount\\n // as basic orders do not have dynamic amounts.\\n calldatacopy(\\n BasicOrder_considerationItem_token_ptr,\\n BasicOrder_considerationToken_cdPtr,\\n ThreeWords\\n )\\n\\n // Copy calldata region with considerationAmount and offerer\\n // from BasicOrderParameters to endAmount and recipient in\\n // ConsiderationItem.\\n calldatacopy(\\n BasicOrder_considerationItem_endAmount_ptr,\\n BasicOrder_considerationAmount_cdPtr,\\n TwoWords\\n )\\n\\n // Calculate EIP712 ConsiderationItem hash and store it in the\\n // array of EIP712 consideration hashes.\\n mstore(\\n BasicOrder_considerationHashesArray_ptr,\\n keccak256(\\n BasicOrder_considerationItem_typeHash_ptr,\\n EIP712_ConsiderationItem_size\\n )\\n )\\n\\n /*\\n * 2. Write a ReceivedItem struct for the primary consideration\\n * item to the consideration array in OrderFulfilled.\\n */\\n\\n // Get the length of the additional recipients array.\\n let totalAdditionalRecipients := calldataload(\\n BasicOrder_additionalRecipients_length_cdPtr\\n )\\n\\n // Calculate pointer to length of OrderFulfilled consideration\\n // array.\\n let eventConsiderationArrPtr := add(\\n OrderFulfilled_consideration_length_baseOffset,\\n mul(totalAdditionalRecipients, OneWord)\\n )\\n\\n // Set the length of the consideration array to the number of\\n // additional recipients, plus one for the primary consideration\\n // item.\\n mstore(\\n eventConsiderationArrPtr,\\n add(\\n calldataload(\\n BasicOrder_additionalRecipients_length_cdPtr\\n ),\\n 1\\n )\\n )\\n\\n // Overwrite the consideration array pointer so it points to the\\n // body of the first element\\n eventConsiderationArrPtr := add(\\n eventConsiderationArrPtr,\\n OneWord\\n )\\n\\n // Set itemType at start of the ReceivedItem memory region.\\n mstore(eventConsiderationArrPtr, receivedItemType)\\n\\n // Copy calldata region (token, identifier, amount & recipient)\\n // from BasicOrderParameters to ReceivedItem memory.\\n calldatacopy(\\n add(eventConsiderationArrPtr, Common_token_offset),\\n BasicOrder_considerationToken_cdPtr,\\n FourWords\\n )\\n\\n /*\\n * 3. Calculate EIP712 ConsiderationItem hashes for original\\n * additional recipients and add a ReceivedItem for each to the\\n * consideration array in the OrderFulfilled event. The original\\n * additional recipients are all the considerations signed by\\n * the offerer aside from the primary consideration of the\\n * order. Uses memory region from 0x80-0x160 as a buffer for\\n * calculating EIP712 ConsiderationItem hashes.\\n */\\n\\n // Put pointer to consideration hashes array on the stack.\\n // This will be updated as each additional recipient is hashed\\n let\\n considerationHashesPtr\\n := BasicOrder_considerationHashesArray_ptr\\n\\n // Write item type, token, & identifier for additional recipient\\n // to memory region for hashing EIP712 ConsiderationItem; these\\n // values will be reused for each recipient.\\n mstore(\\n BasicOrder_considerationItem_itemType_ptr,\\n additionalRecipientsItemType\\n )\\n mstore(\\n BasicOrder_considerationItem_token_ptr,\\n additionalRecipientsToken\\n )\\n mstore(BasicOrder_considerationItem_identifier_ptr, 0)\\n\\n // Read length of the additionalRecipients array from calldata\\n // and iterate.\\n totalAdditionalRecipients := calldataload(\\n BasicOrder_totalOriginalAdditionalRecipients_cdPtr\\n )\\n let i := 0\\n // prettier-ignore\\n for {} lt(i, totalAdditionalRecipients) {\\n i := add(i, 1)\\n } {\\n /*\\n * Calculate EIP712 ConsiderationItem hash for recipient.\\n */\\n\\n // Retrieve calldata pointer for additional recipient.\\n let additionalRecipientCdPtr := add(\\n BasicOrder_additionalRecipients_data_cdPtr,\\n mul(AdditionalRecipients_size, i)\\n )\\n\\n // Copy startAmount from calldata to the ConsiderationItem\\n // struct.\\n calldatacopy(\\n BasicOrder_considerationItem_startAmount_ptr,\\n additionalRecipientCdPtr,\\n OneWord\\n )\\n\\n // Copy endAmount and recipient from calldata to the\\n // ConsiderationItem struct.\\n calldatacopy(\\n BasicOrder_considerationItem_endAmount_ptr,\\n additionalRecipientCdPtr,\\n AdditionalRecipients_size\\n )\\n\\n // Add 1 word to the pointer as part of each loop to reduce\\n // operations needed to get local offset into the array.\\n considerationHashesPtr := add(\\n considerationHashesPtr,\\n OneWord\\n )\\n\\n // Calculate EIP712 ConsiderationItem hash and store it in\\n // the array of consideration hashes.\\n mstore(\\n considerationHashesPtr,\\n keccak256(\\n BasicOrder_considerationItem_typeHash_ptr,\\n EIP712_ConsiderationItem_size\\n )\\n )\\n\\n /*\\n * Write ReceivedItem to OrderFulfilled data.\\n */\\n\\n // At this point, eventConsiderationArrPtr points to the\\n // beginning of the ReceivedItem struct of the previous\\n // element in the array. Increase it by the size of the\\n // struct to arrive at the pointer for the current element.\\n eventConsiderationArrPtr := add(\\n eventConsiderationArrPtr,\\n ReceivedItem_size\\n )\\n\\n // Write itemType to the ReceivedItem struct.\\n mstore(\\n eventConsiderationArrPtr,\\n additionalRecipientsItemType\\n )\\n\\n // Write token to the next word of the ReceivedItem struct.\\n mstore(\\n add(eventConsiderationArrPtr, OneWord),\\n additionalRecipientsToken\\n )\\n\\n // Copy endAmount & recipient words to ReceivedItem struct.\\n calldatacopy(\\n add(\\n eventConsiderationArrPtr,\\n ReceivedItem_amount_offset\\n ),\\n additionalRecipientCdPtr,\\n TwoWords\\n )\\n }\\n\\n /*\\n * 4. Hash packed array of ConsiderationItem EIP712 hashes:\\n * `keccak256(abi.encodePacked(receivedItemHashes))`\\n * Note that it is set at 0x60 \\u2014 all other memory begins at\\n * 0x80. 0x60 is the \\\"zero slot\\\" and will be restored at the end\\n * of the assembly section and before required by the compiler.\\n */\\n mstore(\\n receivedItemsHash_ptr,\\n keccak256(\\n BasicOrder_considerationHashesArray_ptr,\\n mul(add(totalAdditionalRecipients, 1), OneWord)\\n )\\n )\\n\\n /*\\n * 5. Add a ReceivedItem for each tip to the consideration array\\n * in the OrderFulfilled event. The tips are all the\\n * consideration items that were not signed by the offerer and\\n * were provided by the fulfiller.\\n */\\n\\n // Overwrite length to length of the additionalRecipients array.\\n totalAdditionalRecipients := calldataload(\\n BasicOrder_additionalRecipients_length_cdPtr\\n )\\n // prettier-ignore\\n for {} lt(i, totalAdditionalRecipients) {\\n i := add(i, 1)\\n } {\\n // Retrieve calldata pointer for additional recipient.\\n let additionalRecipientCdPtr := add(\\n BasicOrder_additionalRecipients_data_cdPtr,\\n mul(AdditionalRecipients_size, i)\\n )\\n\\n // At this point, eventConsiderationArrPtr points to the\\n // beginning of the ReceivedItem struct of the previous\\n // element in the array. Increase it by the size of the\\n // struct to arrive at the pointer for the current element.\\n eventConsiderationArrPtr := add(\\n eventConsiderationArrPtr,\\n ReceivedItem_size\\n )\\n\\n // Write itemType to the ReceivedItem struct.\\n mstore(\\n eventConsiderationArrPtr,\\n additionalRecipientsItemType\\n )\\n\\n // Write token to the next word of the ReceivedItem struct.\\n mstore(\\n add(eventConsiderationArrPtr, OneWord),\\n additionalRecipientsToken\\n )\\n\\n // Copy endAmount & recipient words to ReceivedItem struct.\\n calldatacopy(\\n add(\\n eventConsiderationArrPtr,\\n ReceivedItem_amount_offset\\n ),\\n additionalRecipientCdPtr,\\n TwoWords\\n )\\n }\\n }\\n }\\n\\n {\\n /**\\n * Next, handle offered items. Memory Layout:\\n * EIP712 data for OfferItem\\n * - 0x80: OfferItem EIP-712 typehash (constant)\\n * - 0xa0: itemType\\n * - 0xc0: token\\n * - 0xe0: identifier (reused for offeredItemsHash)\\n * - 0x100: startAmount\\n * - 0x120: endAmount\\n */\\n\\n // Place offer item typehash on the stack.\\n bytes32 typeHash = _OFFER_ITEM_TYPEHASH;\\n\\n // Utilize assembly to enable reuse of memory regions when possible.\\n assembly {\\n /*\\n * 1. Calculate OfferItem EIP712 hash\\n */\\n\\n // Write the OfferItem typeHash to memory.\\n mstore(BasicOrder_offerItem_typeHash_ptr, typeHash)\\n\\n // Write the OfferItem item type to memory.\\n mstore(BasicOrder_offerItem_itemType_ptr, offeredItemType)\\n\\n // Copy calldata region with (offerToken, offerIdentifier,\\n // offerAmount) from OrderParameters to (token, identifier,\\n // startAmount) in OfferItem struct. The offerAmount is written\\n // to startAmount and endAmount as basic orders do not have\\n // dynamic amounts.\\n calldatacopy(\\n BasicOrder_offerItem_token_ptr,\\n BasicOrder_offerToken_cdPtr,\\n ThreeWords\\n )\\n\\n // Copy offerAmount from calldata to endAmount in OfferItem\\n // struct.\\n calldatacopy(\\n BasicOrder_offerItem_endAmount_ptr,\\n BasicOrder_offerAmount_cdPtr,\\n OneWord\\n )\\n\\n // Compute EIP712 OfferItem hash, write result to scratch space:\\n // `keccak256(abi.encode(offeredItem))`\\n mstore(\\n 0,\\n keccak256(\\n BasicOrder_offerItem_typeHash_ptr,\\n EIP712_OfferItem_size\\n )\\n )\\n\\n /*\\n * 2. Calculate hash of array of EIP712 hashes and write the\\n * result to the corresponding OfferItem struct:\\n * `keccak256(abi.encodePacked(offerItemHashes))`\\n */\\n mstore(BasicOrder_order_offerHashes_ptr, keccak256(0, OneWord))\\n\\n /*\\n * 3. Write SpentItem to offer array in OrderFulfilled event.\\n */\\n let eventConsiderationArrPtr := add(\\n OrderFulfilled_offer_length_baseOffset,\\n mul(\\n calldataload(\\n BasicOrder_additionalRecipients_length_cdPtr\\n ),\\n OneWord\\n )\\n )\\n\\n // Set a length of 1 for the offer array.\\n mstore(eventConsiderationArrPtr, 1)\\n\\n // Write itemType to the SpentItem struct.\\n mstore(add(eventConsiderationArrPtr, OneWord), offeredItemType)\\n\\n // Copy calldata region with (offerToken, offerIdentifier,\\n // offerAmount) from OrderParameters to (token, identifier,\\n // amount) in SpentItem struct.\\n calldatacopy(\\n add(eventConsiderationArrPtr, AdditionalRecipients_size),\\n BasicOrder_offerToken_cdPtr,\\n ThreeWords\\n )\\n }\\n }\\n\\n {\\n /**\\n * Once consideration items and offer items have been handled,\\n * derive the final order hash. Memory Layout:\\n * 0x80-0x1c0: EIP712 data for order\\n * - 0x80: Order EIP-712 typehash (constant)\\n * - 0xa0: orderParameters.offerer\\n * - 0xc0: orderParameters.zone\\n * - 0xe0: keccak256(abi.encodePacked(offerHashes))\\n * - 0x100: keccak256(abi.encodePacked(considerationHashes))\\n * - 0x120: orderParameters.basicOrderType (% 4 = orderType)\\n * - 0x140: orderParameters.startTime\\n * - 0x160: orderParameters.endTime\\n * - 0x180: orderParameters.zoneHash\\n * - 0x1a0: orderParameters.salt\\n * - 0x1c0: orderParameters.conduitKey\\n * - 0x1e0: _counters[orderParameters.offerer] (from storage)\\n */\\n\\n // Read the offerer from calldata and place on the stack.\\n address offerer;\\n assembly {\\n offerer := calldataload(BasicOrder_offerer_cdPtr)\\n }\\n\\n // Read offerer's current counter from storage and place on stack.\\n uint256 counter = _getCounter(offerer);\\n\\n // Load order typehash from runtime code and place on stack.\\n bytes32 typeHash = _ORDER_TYPEHASH;\\n\\n assembly {\\n // Set the OrderItem typeHash in memory.\\n mstore(BasicOrder_order_typeHash_ptr, typeHash)\\n\\n // Copy offerer and zone from OrderParameters in calldata to the\\n // Order struct.\\n calldatacopy(\\n BasicOrder_order_offerer_ptr,\\n BasicOrder_offerer_cdPtr,\\n TwoWords\\n )\\n\\n // Copy receivedItemsHash from zero slot to the Order struct.\\n mstore(\\n BasicOrder_order_considerationHashes_ptr,\\n mload(receivedItemsHash_ptr)\\n )\\n\\n // Write the supplied orderType to the Order struct.\\n mstore(BasicOrder_order_orderType_ptr, orderType)\\n\\n // Copy startTime, endTime, zoneHash, salt & conduit from\\n // calldata to the Order struct.\\n calldatacopy(\\n BasicOrder_order_startTime_ptr,\\n BasicOrder_startTime_cdPtr,\\n FiveWords\\n )\\n\\n // Write offerer's counter, retrieved from storage, to struct.\\n mstore(BasicOrder_order_counter_ptr, counter)\\n\\n // Compute the EIP712 Order hash.\\n orderHash := keccak256(\\n BasicOrder_order_typeHash_ptr,\\n EIP712_Order_size\\n )\\n }\\n }\\n\\n assembly {\\n /**\\n * After the order hash has been derived, emit OrderFulfilled event:\\n * event OrderFulfilled(\\n * bytes32 orderHash,\\n * address indexed offerer,\\n * address indexed zone,\\n * address fulfiller,\\n * SpentItem[] offer,\\n * > (itemType, token, id, amount)\\n * ReceivedItem[] consideration\\n * > (itemType, token, id, amount, recipient)\\n * )\\n * topic0 - OrderFulfilled event signature\\n * topic1 - offerer\\n * topic2 - zone\\n * data:\\n * - 0x00: orderHash\\n * - 0x20: fulfiller\\n * - 0x40: offer arr ptr (0x80)\\n * - 0x60: consideration arr ptr (0x120)\\n * - 0x80: offer arr len (1)\\n * - 0xa0: offer.itemType\\n * - 0xc0: offer.token\\n * - 0xe0: offer.identifier\\n * - 0x100: offer.amount\\n * - 0x120: 1 + recipients.length\\n * - 0x140: recipient 0\\n */\\n\\n // Derive pointer to start of OrderFulfilled event data\\n let eventDataPtr := add(\\n OrderFulfilled_baseOffset,\\n mul(\\n calldataload(BasicOrder_additionalRecipients_length_cdPtr),\\n OneWord\\n )\\n )\\n\\n // Write the order hash to the head of the event's data region.\\n mstore(eventDataPtr, orderHash)\\n\\n // Write the fulfiller (i.e. the caller) next for receiver argument.\\n mstore(add(eventDataPtr, OrderFulfilled_fulfiller_offset), caller())\\n\\n // Write the SpentItem and ReceivedItem array offsets (constants).\\n mstore(\\n // SpentItem array offset\\n add(eventDataPtr, OrderFulfilled_offer_head_offset),\\n OrderFulfilled_offer_body_offset\\n )\\n mstore(\\n // ReceivedItem array offset\\n add(eventDataPtr, OrderFulfilled_consideration_head_offset),\\n OrderFulfilled_consideration_body_offset\\n )\\n\\n // Derive total data size including SpentItem and ReceivedItem data.\\n // SpentItem portion is already included in the baseSize constant,\\n // as there can only be one element in the array.\\n let dataSize := add(\\n OrderFulfilled_baseSize,\\n mul(\\n calldataload(BasicOrder_additionalRecipients_length_cdPtr),\\n ReceivedItem_size\\n )\\n )\\n\\n // Emit OrderFulfilled log with three topics (the event signature\\n // as well as the two indexed arguments, the offerer and the zone).\\n log3(\\n // Supply the pointer for event data in memory.\\n eventDataPtr,\\n // Supply the size of event data in memory.\\n dataSize,\\n // Supply the OrderFulfilled event signature.\\n OrderFulfilled_selector,\\n // Supply the first topic (the offerer).\\n calldataload(BasicOrder_offerer_cdPtr),\\n // Supply the second topic (the zone).\\n calldataload(BasicOrder_zone_cdPtr)\\n )\\n\\n // Restore the zero slot.\\n mstore(ZeroSlot, 0)\\n }\\n\\n // Determine whether order is restricted and, if so, that it is valid.\\n _assertRestrictedBasicOrderValidity(\\n orderHash,\\n parameters.zoneHash,\\n orderType,\\n parameters.offerer,\\n parameters.zone\\n );\\n\\n // Verify and update the status of the derived order.\\n _validateBasicOrderAndUpdateStatus(\\n orderHash,\\n parameters.offerer,\\n parameters.signature\\n );\\n }\\n\\n /**\\n * @dev Internal function to transfer Ether (or other native tokens) to a\\n * given recipient as part of basic order fulfillment. Note that\\n * conduits are not utilized for native tokens as the transferred\\n * amount must be provided as msg.value.\\n *\\n * @param amount The amount to transfer.\\n * @param to The recipient of the native token transfer.\\n * @param additionalRecipients The additional recipients of the order.\\n */\\n function _transferEthAndFinalize(\\n uint256 amount,\\n address payable to,\\n AdditionalRecipient[] calldata additionalRecipients\\n ) internal {\\n // Put ether value supplied by the caller on the stack.\\n uint256 etherRemaining = msg.value;\\n\\n // Retrieve total number of additional recipients and place on stack.\\n uint256 totalAdditionalRecipients = additionalRecipients.length;\\n\\n // Skip overflow check as for loop is indexed starting at zero.\\n unchecked {\\n // Iterate over each additional recipient.\\n for (uint256 i = 0; i < totalAdditionalRecipients; ++i) {\\n // Retrieve the additional recipient.\\n AdditionalRecipient calldata additionalRecipient = (\\n additionalRecipients[i]\\n );\\n\\n // Read ether amount to transfer to recipient & place on stack.\\n uint256 additionalRecipientAmount = additionalRecipient.amount;\\n\\n // Ensure that sufficient Ether is available.\\n if (additionalRecipientAmount > etherRemaining) {\\n revert InsufficientEtherSupplied();\\n }\\n\\n // Transfer Ether to the additional recipient.\\n _transferEth(\\n additionalRecipient.recipient,\\n additionalRecipientAmount\\n );\\n\\n // Reduce ether value available. Skip underflow check as\\n // subtracted value is confirmed above as less than remaining.\\n etherRemaining -= additionalRecipientAmount;\\n }\\n }\\n\\n // Ensure that sufficient Ether is still available.\\n if (amount > etherRemaining) {\\n revert InsufficientEtherSupplied();\\n }\\n\\n // Transfer Ether to the offerer.\\n _transferEth(to, amount);\\n\\n // If any Ether remains after transfers, return it to the caller.\\n if (etherRemaining > amount) {\\n // Skip underflow check as etherRemaining > amount.\\n unchecked {\\n // Transfer remaining Ether to the caller.\\n _transferEth(payable(msg.sender), etherRemaining - amount);\\n }\\n }\\n }\\n\\n /**\\n * @dev Internal function to transfer ERC20 tokens to a given recipient as\\n * part of basic order fulfillment.\\n *\\n * @param offerer The offerer of the fulfiller order.\\n * @param parameters The basic order parameters.\\n * @param fromOfferer A boolean indicating whether to decrement amount from\\n * the offered amount.\\n * @param accumulator An open-ended array that collects transfers to execute\\n * against a given conduit in a single call.\\n */\\n function _transferERC20AndFinalize(\\n address offerer,\\n BasicOrderParameters calldata parameters,\\n bool fromOfferer,\\n bytes memory accumulator\\n ) internal {\\n // Declare from and to variables determined by fromOfferer value.\\n address from;\\n address to;\\n\\n // Declare token and amount variables determined by fromOfferer value.\\n address token;\\n uint256 amount;\\n\\n // Declare and check identifier variable within an isolated scope.\\n {\\n // Declare identifier variable determined by fromOfferer value.\\n uint256 identifier;\\n\\n // Set ERC20 token transfer variables based on fromOfferer boolean.\\n if (fromOfferer) {\\n // Use offerer as from value and msg.sender as to value.\\n from = offerer;\\n to = msg.sender;\\n\\n // Use offer token and related values if token is from offerer.\\n token = parameters.offerToken;\\n identifier = parameters.offerIdentifier;\\n amount = parameters.offerAmount;\\n } else {\\n // Use msg.sender as from value and offerer as to value.\\n from = msg.sender;\\n to = offerer;\\n\\n // Otherwise, use consideration token and related values.\\n token = parameters.considerationToken;\\n identifier = parameters.considerationIdentifier;\\n amount = parameters.considerationAmount;\\n }\\n\\n // Ensure that no identifier is supplied.\\n if (identifier != 0) {\\n revert UnusedItemParameters();\\n }\\n }\\n\\n // Determine the appropriate conduit to utilize.\\n bytes32 conduitKey;\\n\\n // Utilize assembly to derive conduit (if relevant) based on route.\\n assembly {\\n // Use offerer conduit if fromOfferer, fulfiller conduit otherwise.\\n conduitKey := calldataload(\\n sub(\\n BasicOrder_fulfillerConduit_cdPtr,\\n mul(fromOfferer, OneWord)\\n )\\n )\\n }\\n\\n // Retrieve total number of additional recipients and place on stack.\\n uint256 totalAdditionalRecipients = (\\n parameters.additionalRecipients.length\\n );\\n\\n // Iterate over each additional recipient.\\n for (uint256 i = 0; i < totalAdditionalRecipients; ) {\\n // Retrieve the additional recipient.\\n AdditionalRecipient calldata additionalRecipient = (\\n parameters.additionalRecipients[i]\\n );\\n\\n uint256 additionalRecipientAmount = additionalRecipient.amount;\\n\\n // Decrement the amount to transfer to fulfiller if indicated.\\n if (fromOfferer) {\\n amount -= additionalRecipientAmount;\\n }\\n\\n // Transfer ERC20 tokens to additional recipient given approval.\\n _transferERC20(\\n token,\\n from,\\n additionalRecipient.recipient,\\n additionalRecipientAmount,\\n conduitKey,\\n accumulator\\n );\\n\\n // Skip overflow check as for loop is indexed starting at zero.\\n unchecked {\\n ++i;\\n }\\n }\\n\\n // Transfer ERC20 token amount (from account must have proper approval).\\n _transferERC20(token, from, to, amount, conduitKey, accumulator);\\n }\\n}\\n\",\"keccak256\":\"0xb40984640645315010a9824fc9edd107700c6204ff86c22a2b627416ccdde94f\",\"license\":\"MIT\"},\"contracts/lib/Consideration.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.13;\\n\\n// prettier-ignore\\nimport {\\n ConsiderationInterface\\n} from \\\"../interfaces/ConsiderationInterface.sol\\\";\\n\\n// prettier-ignore\\nimport {\\n OrderComponents,\\n BasicOrderParameters,\\n OrderParameters,\\n Order,\\n AdvancedOrder,\\n OrderStatus,\\n CriteriaResolver,\\n Fulfillment,\\n FulfillmentComponent,\\n Execution\\n} from \\\"./ConsiderationStructs.sol\\\";\\n\\nimport { OrderCombiner } from \\\"./OrderCombiner.sol\\\";\\n\\n/**\\n * @title Consideration\\n * @author 0age\\n * @custom:coauthor d1ll0n\\n * @custom:coauthor transmissions11\\n * @custom:version 1.1\\n * @notice Consideration is a generalized ETH/ERC20/ERC721/ERC1155 marketplace.\\n * It minimizes external calls to the greatest extent possible and\\n * provides lightweight methods for common routes as well as more\\n * flexible methods for composing advanced orders or groups of orders.\\n * Each order contains an arbitrary number of items that may be spent\\n * (the \\\"offer\\\") along with an arbitrary number of items that must be\\n * received back by the indicated recipients (the \\\"consideration\\\").\\n */\\ncontract Consideration is ConsiderationInterface, OrderCombiner {\\n /**\\n * @notice Derive and set hashes, reference chainId, and associated domain\\n * separator during deployment.\\n *\\n * @param conduitController A contract that deploys conduits, or proxies\\n * that may optionally be used to transfer approved\\n * ERC20/721/1155 tokens.\\n */\\n constructor(address conduitController) OrderCombiner(conduitController) {}\\n\\n /**\\n * @notice Fulfill an order offering an ERC20, ERC721, or ERC1155 item by\\n * supplying Ether (or other native tokens), ERC20 tokens, an ERC721\\n * item, or an ERC1155 item as consideration. Six permutations are\\n * supported: Native token to ERC721, Native token to ERC1155, ERC20\\n * to ERC721, ERC20 to ERC1155, ERC721 to ERC20, and ERC1155 to\\n * ERC20 (with native tokens supplied as msg.value). For an order to\\n * be eligible for fulfillment via this method, it must contain a\\n * single offer item (though that item may have a greater amount if\\n * the item is not an ERC721). An arbitrary number of \\\"additional\\n * recipients\\\" may also be supplied which will each receive native\\n * tokens or ERC20 items from the fulfiller as consideration. Refer\\n * to the documentation for a more comprehensive summary of how to\\n * utilize this method and what orders are compatible with it.\\n *\\n * @param parameters Additional information on the fulfilled order. Note\\n * that the offerer and the fulfiller must first approve\\n * this contract (or their chosen conduit if indicated)\\n * before any tokens can be transferred. Also note that\\n * contract recipients of ERC1155 consideration items must\\n * implement `onERC1155Received` in order to receive those\\n * items.\\n *\\n * @return fulfilled A boolean indicating whether the order has been\\n * successfully fulfilled.\\n */\\n function fulfillBasicOrder(BasicOrderParameters calldata parameters)\\n external\\n payable\\n override\\n returns (bool fulfilled)\\n {\\n // Validate and fulfill the basic order.\\n fulfilled = _validateAndFulfillBasicOrder(parameters);\\n }\\n\\n /**\\n * @notice Fulfill an order with an arbitrary number of items for offer and\\n * consideration. Note that this function does not support\\n * criteria-based orders or partial filling of orders (though\\n * filling the remainder of a partially-filled order is supported).\\n *\\n * @param order The order to fulfill. Note that both the\\n * offerer and the fulfiller must first approve\\n * this contract (or the corresponding conduit if\\n * indicated) to transfer any relevant tokens on\\n * their behalf and that contracts must implement\\n * `onERC1155Received` to receive ERC1155 tokens\\n * as consideration.\\n * @param fulfillerConduitKey A bytes32 value indicating what conduit, if\\n * any, to source the fulfiller's token approvals\\n * from. The zero hash signifies that no conduit\\n * should be used (and direct approvals set on\\n * Consideration).\\n *\\n * @return fulfilled A boolean indicating whether the order has been\\n * successfully fulfilled.\\n */\\n function fulfillOrder(Order calldata order, bytes32 fulfillerConduitKey)\\n external\\n payable\\n override\\n returns (bool fulfilled)\\n {\\n // Convert order to \\\"advanced\\\" order, then validate and fulfill it.\\n fulfilled = _validateAndFulfillAdvancedOrder(\\n _convertOrderToAdvanced(order),\\n new CriteriaResolver[](0), // No criteria resolvers supplied.\\n fulfillerConduitKey,\\n msg.sender\\n );\\n }\\n\\n /**\\n * @notice Fill an order, fully or partially, with an arbitrary number of\\n * items for offer and consideration alongside criteria resolvers\\n * containing specific token identifiers and associated proofs.\\n *\\n * @param advancedOrder The order to fulfill along with the fraction\\n * of the order to attempt to fill. Note that\\n * both the offerer and the fulfiller must first\\n * approve this contract (or their conduit if\\n * indicated by the order) to transfer any\\n * relevant tokens on their behalf and that\\n * contracts must implement `onERC1155Received`\\n * to receive ERC1155 tokens as consideration.\\n * Also note that all offer and consideration\\n * components must have no remainder after\\n * multiplication of the respective amount with\\n * the supplied fraction for the partial fill to\\n * be considered valid.\\n * @param criteriaResolvers An array where each element contains a\\n * reference to a specific offer or\\n * consideration, a token identifier, and a proof\\n * that the supplied token identifier is\\n * contained in the merkle root held by the item\\n * in question's criteria element. Note that an\\n * empty criteria indicates that any\\n * (transferable) token identifier on the token\\n * in question is valid and that no associated\\n * proof needs to be supplied.\\n * @param fulfillerConduitKey A bytes32 value indicating what conduit, if\\n * any, to source the fulfiller's token approvals\\n * from. The zero hash signifies that no conduit\\n * should be used (and direct approvals set on\\n * Consideration).\\n * @param recipient The intended recipient for all received items,\\n * with `address(0)` indicating that the caller\\n * should receive the items.\\n *\\n * @return fulfilled A boolean indicating whether the order has been\\n * successfully fulfilled.\\n */\\n function fulfillAdvancedOrder(\\n AdvancedOrder calldata advancedOrder,\\n CriteriaResolver[] calldata criteriaResolvers,\\n bytes32 fulfillerConduitKey,\\n address recipient\\n ) external payable override returns (bool fulfilled) {\\n // Validate and fulfill the order.\\n fulfilled = _validateAndFulfillAdvancedOrder(\\n advancedOrder,\\n criteriaResolvers,\\n fulfillerConduitKey,\\n recipient == address(0) ? msg.sender : recipient\\n );\\n }\\n\\n /**\\n * @notice Attempt to fill a group of orders, each with an arbitrary number\\n * of items for offer and consideration. Any order that is not\\n * currently active, has already been fully filled, or has been\\n * cancelled will be omitted. Remaining offer and consideration\\n * items will then be aggregated where possible as indicated by the\\n * supplied offer and consideration component arrays and aggregated\\n * items will be transferred to the fulfiller or to each intended\\n * recipient, respectively. Note that a failing item transfer or an\\n * issue with order formatting will cause the entire batch to fail.\\n * Note that this function does not support criteria-based orders or\\n * partial filling of orders (though filling the remainder of a\\n * partially-filled order is supported).\\n *\\n * @param orders The orders to fulfill. Note that both\\n * the offerer and the fulfiller must first\\n * approve this contract (or the\\n * corresponding conduit if indicated) to\\n * transfer any relevant tokens on their\\n * behalf and that contracts must implement\\n * `onERC1155Received` to receive ERC1155\\n * tokens as consideration.\\n * @param offerFulfillments An array of FulfillmentComponent arrays\\n * indicating which offer items to attempt\\n * to aggregate when preparing executions.\\n * @param considerationFulfillments An array of FulfillmentComponent arrays\\n * indicating which consideration items to\\n * attempt to aggregate when preparing\\n * executions.\\n * @param fulfillerConduitKey A bytes32 value indicating what conduit,\\n * if any, to source the fulfiller's token\\n * approvals from. The zero hash signifies\\n * that no conduit should be used (and\\n * direct approvals set on Consideration).\\n * @param maximumFulfilled The maximum number of orders to fulfill.\\n *\\n * @return availableOrders An array of booleans indicating if each order\\n * with an index corresponding to the index of the\\n * returned boolean was fulfillable or not.\\n * @return executions An array of elements indicating the sequence of\\n * transfers performed as part of matching the given\\n * orders.\\n */\\n function fulfillAvailableOrders(\\n Order[] calldata orders,\\n FulfillmentComponent[][] calldata offerFulfillments,\\n FulfillmentComponent[][] calldata considerationFulfillments,\\n bytes32 fulfillerConduitKey,\\n uint256 maximumFulfilled\\n )\\n external\\n payable\\n override\\n returns (bool[] memory availableOrders, Execution[] memory executions)\\n {\\n // Convert orders to \\\"advanced\\\" orders and fulfill all available orders.\\n return\\n _fulfillAvailableAdvancedOrders(\\n _convertOrdersToAdvanced(orders), // Convert to advanced orders.\\n new CriteriaResolver[](0), // No criteria resolvers supplied.\\n offerFulfillments,\\n considerationFulfillments,\\n fulfillerConduitKey,\\n msg.sender,\\n maximumFulfilled\\n );\\n }\\n\\n /**\\n * @notice Attempt to fill a group of orders, fully or partially, with an\\n * arbitrary number of items for offer and consideration per order\\n * alongside criteria resolvers containing specific token\\n * identifiers and associated proofs. Any order that is not\\n * currently active, has already been fully filled, or has been\\n * cancelled will be omitted. Remaining offer and consideration\\n * items will then be aggregated where possible as indicated by the\\n * supplied offer and consideration component arrays and aggregated\\n * items will be transferred to the fulfiller or to each intended\\n * recipient, respectively. Note that a failing item transfer or an\\n * issue with order formatting will cause the entire batch to fail.\\n *\\n * @param advancedOrders The orders to fulfill along with the\\n * fraction of those orders to attempt to\\n * fill. Note that both the offerer and the\\n * fulfiller must first approve this\\n * contract (or their conduit if indicated\\n * by the order) to transfer any relevant\\n * tokens on their behalf and that\\n * contracts must implement\\n * `onERC1155Received` in order to receive\\n * ERC1155 tokens as consideration. Also\\n * note that all offer and consideration\\n * components must have no remainder after\\n * multiplication of the respective amount\\n * with the supplied fraction for an\\n * order's partial fill amount to be\\n * considered valid.\\n * @param criteriaResolvers An array where each element contains a\\n * reference to a specific offer or\\n * consideration, a token identifier, and a\\n * proof that the supplied token identifier\\n * is contained in the merkle root held by\\n * the item in question's criteria element.\\n * Note that an empty criteria indicates\\n * that any (transferable) token\\n * identifier on the token in question is\\n * valid and that no associated proof needs\\n * to be supplied.\\n * @param offerFulfillments An array of FulfillmentComponent arrays\\n * indicating which offer items to attempt\\n * to aggregate when preparing executions.\\n * @param considerationFulfillments An array of FulfillmentComponent arrays\\n * indicating which consideration items to\\n * attempt to aggregate when preparing\\n * executions.\\n * @param fulfillerConduitKey A bytes32 value indicating what conduit,\\n * if any, to source the fulfiller's token\\n * approvals from. The zero hash signifies\\n * that no conduit should be used (and\\n * direct approvals set on Consideration).\\n * @param recipient The intended recipient for all received\\n * items, with `address(0)` indicating that\\n * the caller should receive the items.\\n * @param maximumFulfilled The maximum number of orders to fulfill.\\n *\\n * @return availableOrders An array of booleans indicating if each order\\n * with an index corresponding to the index of the\\n * returned boolean was fulfillable or not.\\n * @return executions An array of elements indicating the sequence of\\n * transfers performed as part of matching the given\\n * orders.\\n */\\n function fulfillAvailableAdvancedOrders(\\n AdvancedOrder[] memory advancedOrders,\\n CriteriaResolver[] calldata criteriaResolvers,\\n FulfillmentComponent[][] calldata offerFulfillments,\\n FulfillmentComponent[][] calldata considerationFulfillments,\\n bytes32 fulfillerConduitKey,\\n address recipient,\\n uint256 maximumFulfilled\\n )\\n external\\n payable\\n override\\n returns (bool[] memory availableOrders, Execution[] memory executions)\\n {\\n // Fulfill all available orders.\\n return\\n _fulfillAvailableAdvancedOrders(\\n advancedOrders,\\n criteriaResolvers,\\n offerFulfillments,\\n considerationFulfillments,\\n fulfillerConduitKey,\\n recipient == address(0) ? msg.sender : recipient,\\n maximumFulfilled\\n );\\n }\\n\\n /**\\n * @notice Match an arbitrary number of orders, each with an arbitrary\\n * number of items for offer and consideration along with a set of\\n * fulfillments allocating offer components to consideration\\n * components. Note that this function does not support\\n * criteria-based or partial filling of orders (though filling the\\n * remainder of a partially-filled order is supported).\\n *\\n * @param orders The orders to match. Note that both the offerer\\n * and fulfiller on each order must first approve\\n * this contract (or their conduit if indicated by\\n * the order) to transfer any relevant tokens on\\n * their behalf and each consideration recipient\\n * must implement `onERC1155Received` in order to\\n * receive ERC1155 tokens.\\n * @param fulfillments An array of elements allocating offer components\\n * to consideration components. Note that each\\n * consideration component must be fully met in\\n * order for the match operation to be valid.\\n *\\n * @return executions An array of elements indicating the sequence of\\n * transfers performed as part of matching the given\\n * orders.\\n */\\n function matchOrders(\\n Order[] calldata orders,\\n Fulfillment[] calldata fulfillments\\n ) external payable override returns (Execution[] memory executions) {\\n // Convert to advanced, validate, and match orders using fulfillments.\\n return\\n _matchAdvancedOrders(\\n _convertOrdersToAdvanced(orders),\\n new CriteriaResolver[](0), // No criteria resolvers supplied.\\n fulfillments\\n );\\n }\\n\\n /**\\n * @notice Match an arbitrary number of full or partial orders, each with an\\n * arbitrary number of items for offer and consideration, supplying\\n * criteria resolvers containing specific token identifiers and\\n * associated proofs as well as fulfillments allocating offer\\n * components to consideration components.\\n *\\n * @param advancedOrders The advanced orders to match. Note that both the\\n * offerer and fulfiller on each order must first\\n * approve this contract (or their conduit if\\n * indicated by the order) to transfer any relevant\\n * tokens on their behalf and each consideration\\n * recipient must implement `onERC1155Received` in\\n * order to receive ERC1155 tokens. Also note that\\n * the offer and consideration components for each\\n * order must have no remainder after multiplying\\n * the respective amount with the supplied fraction\\n * in order for the group of partial fills to be\\n * considered valid.\\n * @param criteriaResolvers An array where each element contains a reference\\n * to a specific order as well as that order's\\n * offer or consideration, a token identifier, and\\n * a proof that the supplied token identifier is\\n * contained in the order's merkle root. Note that\\n * an empty root indicates that any (transferable)\\n * token identifier is valid and that no associated\\n * proof needs to be supplied.\\n * @param fulfillments An array of elements allocating offer components\\n * to consideration components. Note that each\\n * consideration component must be fully met in\\n * order for the match operation to be valid.\\n *\\n * @return executions An array of elements indicating the sequence of\\n * transfers performed as part of matching the given\\n * orders.\\n */\\n function matchAdvancedOrders(\\n AdvancedOrder[] memory advancedOrders,\\n CriteriaResolver[] calldata criteriaResolvers,\\n Fulfillment[] calldata fulfillments\\n ) external payable override returns (Execution[] memory executions) {\\n // Validate and match the advanced orders using supplied fulfillments.\\n return\\n _matchAdvancedOrders(\\n advancedOrders,\\n criteriaResolvers,\\n fulfillments\\n );\\n }\\n\\n /**\\n * @notice Cancel an arbitrary number of orders. Note that only the offerer\\n * or the zone of a given order may cancel it. Callers should ensure\\n * that the intended order was cancelled by calling `getOrderStatus`\\n * and confirming that `isCancelled` returns `true`.\\n *\\n * @param orders The orders to cancel.\\n *\\n * @return cancelled A boolean indicating whether the supplied orders have\\n * been successfully cancelled.\\n */\\n function cancel(OrderComponents[] calldata orders)\\n external\\n override\\n returns (bool cancelled)\\n {\\n // Cancel the orders.\\n cancelled = _cancel(orders);\\n }\\n\\n /**\\n * @notice Validate an arbitrary number of orders, thereby registering their\\n * signatures as valid and allowing the fulfiller to skip signature\\n * verification on fulfillment. Note that validated orders may still\\n * be unfulfillable due to invalid item amounts or other factors;\\n * callers should determine whether validated orders are fulfillable\\n * by simulating the fulfillment call prior to execution. Also note\\n * that anyone can validate a signed order, but only the offerer can\\n * validate an order without supplying a signature.\\n *\\n * @param orders The orders to validate.\\n *\\n * @return validated A boolean indicating whether the supplied orders have\\n * been successfully validated.\\n */\\n function validate(Order[] calldata orders)\\n external\\n override\\n returns (bool validated)\\n {\\n // Validate the orders.\\n validated = _validate(orders);\\n }\\n\\n /**\\n * @notice Cancel all orders from a given offerer with a given zone in bulk\\n * by incrementing a counter. Note that only the offerer may\\n * increment the counter.\\n *\\n * @return newCounter The new counter.\\n */\\n function incrementCounter() external override returns (uint256 newCounter) {\\n // Increment current counter for the supplied offerer.\\n newCounter = _incrementCounter();\\n }\\n\\n /**\\n * @notice Retrieve the order hash for a given order.\\n *\\n * @param order The components of the order.\\n *\\n * @return orderHash The order hash.\\n */\\n function getOrderHash(OrderComponents calldata order)\\n external\\n view\\n override\\n returns (bytes32 orderHash)\\n {\\n // Derive order hash by supplying order parameters along with counter.\\n orderHash = _deriveOrderHash(\\n OrderParameters(\\n order.offerer,\\n order.zone,\\n order.offer,\\n order.consideration,\\n order.orderType,\\n order.startTime,\\n order.endTime,\\n order.zoneHash,\\n order.salt,\\n order.conduitKey,\\n order.consideration.length\\n ),\\n order.counter\\n );\\n }\\n\\n /**\\n * @notice Retrieve the status of a given order by hash, including whether\\n * the order has been cancelled or validated and the fraction of the\\n * order that has been filled.\\n *\\n * @param orderHash The order hash in question.\\n *\\n * @return isValidated A boolean indicating whether the order in question\\n * has been validated (i.e. previously approved or\\n * partially filled).\\n * @return isCancelled A boolean indicating whether the order in question\\n * has been cancelled.\\n * @return totalFilled The total portion of the order that has been filled\\n * (i.e. the \\\"numerator\\\").\\n * @return totalSize The total size of the order that is either filled or\\n * unfilled (i.e. the \\\"denominator\\\").\\n */\\n function getOrderStatus(bytes32 orderHash)\\n external\\n view\\n override\\n returns (\\n bool isValidated,\\n bool isCancelled,\\n uint256 totalFilled,\\n uint256 totalSize\\n )\\n {\\n // Retrieve the order status using the order hash.\\n return _getOrderStatus(orderHash);\\n }\\n\\n /**\\n * @notice Retrieve the current counter for a given offerer.\\n *\\n * @param offerer The offerer in question.\\n *\\n * @return counter The current counter.\\n */\\n function getCounter(address offerer)\\n external\\n view\\n override\\n returns (uint256 counter)\\n {\\n // Return the counter for the supplied offerer.\\n counter = _getCounter(offerer);\\n }\\n\\n /**\\n * @notice Retrieve configuration information for this contract.\\n *\\n * @return version The contract version.\\n * @return domainSeparator The domain separator for this contract.\\n * @return conduitController The conduit Controller set for this contract.\\n */\\n function information()\\n external\\n view\\n override\\n returns (\\n string memory version,\\n bytes32 domainSeparator,\\n address conduitController\\n )\\n {\\n // Return the information for this contract.\\n return _information();\\n }\\n\\n /**\\n * @notice Retrieve the name of this contract.\\n *\\n * @return contractName The name of this contract.\\n */\\n function name()\\n external\\n pure\\n override\\n returns (string memory contractName)\\n {\\n // Return the name of the contract.\\n contractName = _name();\\n }\\n}\\n\",\"keccak256\":\"0x4044b1011cd1f2fd2b942aa9326b9eb70e653e5f01e997715cd4d4ffb78e123b\",\"license\":\"MIT\"},\"contracts/lib/ConsiderationBase.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.13;\\n\\n// prettier-ignore\\nimport {\\n ConduitControllerInterface\\n} from \\\"../interfaces/ConduitControllerInterface.sol\\\";\\n\\n// prettier-ignore\\nimport {\\n ConsiderationEventsAndErrors\\n} from \\\"../interfaces/ConsiderationEventsAndErrors.sol\\\";\\n\\nimport \\\"./ConsiderationConstants.sol\\\";\\n\\n/**\\n * @title ConsiderationBase\\n * @author 0age\\n * @notice ConsiderationBase contains immutable constants and constructor logic.\\n */\\ncontract ConsiderationBase is ConsiderationEventsAndErrors {\\n // Precompute hashes, original chainId, and domain separator on deployment.\\n bytes32 internal immutable _NAME_HASH;\\n bytes32 internal immutable _VERSION_HASH;\\n bytes32 internal immutable _EIP_712_DOMAIN_TYPEHASH;\\n bytes32 internal immutable _OFFER_ITEM_TYPEHASH;\\n bytes32 internal immutable _CONSIDERATION_ITEM_TYPEHASH;\\n bytes32 internal immutable _ORDER_TYPEHASH;\\n uint256 internal immutable _CHAIN_ID;\\n bytes32 internal immutable _DOMAIN_SEPARATOR;\\n\\n // Allow for interaction with the conduit controller.\\n ConduitControllerInterface internal immutable _CONDUIT_CONTROLLER;\\n\\n // Cache the conduit creation code hash used by the conduit controller.\\n bytes32 internal immutable _CONDUIT_CREATION_CODE_HASH;\\n\\n /**\\n * @dev Derive and set hashes, reference chainId, and associated domain\\n * separator during deployment.\\n *\\n * @param conduitController A contract that deploys conduits, or proxies\\n * that may optionally be used to transfer approved\\n * ERC20/721/1155 tokens.\\n */\\n constructor(address conduitController) {\\n // Derive name and version hashes alongside required EIP-712 typehashes.\\n (\\n _NAME_HASH,\\n _VERSION_HASH,\\n _EIP_712_DOMAIN_TYPEHASH,\\n _OFFER_ITEM_TYPEHASH,\\n _CONSIDERATION_ITEM_TYPEHASH,\\n _ORDER_TYPEHASH\\n ) = _deriveTypehashes();\\n\\n // Store the current chainId and derive the current domain separator.\\n _CHAIN_ID = block.chainid;\\n _DOMAIN_SEPARATOR = _deriveDomainSeparator();\\n\\n // Set the supplied conduit controller.\\n _CONDUIT_CONTROLLER = ConduitControllerInterface(conduitController);\\n\\n // Retrieve the conduit creation code hash from the supplied controller.\\n (_CONDUIT_CREATION_CODE_HASH, ) = (\\n _CONDUIT_CONTROLLER.getConduitCodeHashes()\\n );\\n }\\n\\n /**\\n * @dev Internal view function to derive the EIP-712 domain separator.\\n *\\n * @return The derived domain separator.\\n */\\n function _deriveDomainSeparator() internal view returns (bytes32) {\\n // prettier-ignore\\n return keccak256(\\n abi.encode(\\n _EIP_712_DOMAIN_TYPEHASH,\\n _NAME_HASH,\\n _VERSION_HASH,\\n block.chainid,\\n address(this)\\n )\\n );\\n }\\n\\n /**\\n * @dev Internal pure function to retrieve the default name of this\\n * contract and return.\\n *\\n * @return The name of this contract.\\n */\\n function _name() internal pure virtual returns (string memory) {\\n // Return the name of the contract.\\n assembly {\\n // First element is the offset for the returned string. Offset the\\n // value in memory by one word so that the free memory pointer will\\n // be overwritten by the next write.\\n mstore(OneWord, OneWord)\\n\\n // Name is right padded, so it touches the length which is left\\n // padded. This enables writing both values at once. The free memory\\n // pointer will be overwritten in the process.\\n mstore(NameLengthPtr, NameWithLength)\\n\\n // Standard ABI encoding pads returned data to the nearest word. Use\\n // the already empty zero slot memory region for this purpose and\\n // return the final name string, offset by the original single word.\\n return(OneWord, ThreeWords)\\n }\\n }\\n\\n /**\\n * @dev Internal pure function to retrieve the default name of this contract\\n * as a string that can be used internally.\\n *\\n * @return The name of this contract.\\n */\\n function _nameString() internal pure virtual returns (string memory) {\\n // Return the name of the contract.\\n return \\\"Consideration\\\";\\n }\\n\\n /**\\n * @dev Internal pure function to derive required EIP-712 typehashes and\\n * other hashes during contract creation.\\n *\\n * @return nameHash The hash of the name of the contract.\\n * @return versionHash The hash of the version string of the\\n * contract.\\n * @return eip712DomainTypehash The primary EIP-712 domain typehash.\\n * @return offerItemTypehash The EIP-712 typehash for OfferItem\\n * types.\\n * @return considerationItemTypehash The EIP-712 typehash for\\n * ConsiderationItem types.\\n * @return orderTypehash The EIP-712 typehash for Order types.\\n */\\n function _deriveTypehashes()\\n internal\\n pure\\n returns (\\n bytes32 nameHash,\\n bytes32 versionHash,\\n bytes32 eip712DomainTypehash,\\n bytes32 offerItemTypehash,\\n bytes32 considerationItemTypehash,\\n bytes32 orderTypehash\\n )\\n {\\n // Derive hash of the name of the contract.\\n nameHash = keccak256(bytes(_nameString()));\\n\\n // Derive hash of the version string of the contract.\\n versionHash = keccak256(bytes(\\\"1.1\\\"));\\n\\n // Construct the OfferItem type string.\\n // prettier-ignore\\n bytes memory offerItemTypeString = abi.encodePacked(\\n \\\"OfferItem(\\\",\\n \\\"uint8 itemType,\\\",\\n \\\"address token,\\\",\\n \\\"uint256 identifierOrCriteria,\\\",\\n \\\"uint256 startAmount,\\\",\\n \\\"uint256 endAmount\\\",\\n \\\")\\\"\\n );\\n\\n // Construct the ConsiderationItem type string.\\n // prettier-ignore\\n bytes memory considerationItemTypeString = abi.encodePacked(\\n \\\"ConsiderationItem(\\\",\\n \\\"uint8 itemType,\\\",\\n \\\"address token,\\\",\\n \\\"uint256 identifierOrCriteria,\\\",\\n \\\"uint256 startAmount,\\\",\\n \\\"uint256 endAmount,\\\",\\n \\\"address recipient\\\",\\n \\\")\\\"\\n );\\n\\n // Construct the OrderComponents type string, not including the above.\\n // prettier-ignore\\n bytes memory orderComponentsPartialTypeString = abi.encodePacked(\\n \\\"OrderComponents(\\\",\\n \\\"address offerer,\\\",\\n \\\"address zone,\\\",\\n \\\"OfferItem[] offer,\\\",\\n \\\"ConsiderationItem[] consideration,\\\",\\n \\\"uint8 orderType,\\\",\\n \\\"uint256 startTime,\\\",\\n \\\"uint256 endTime,\\\",\\n \\\"bytes32 zoneHash,\\\",\\n \\\"uint256 salt,\\\",\\n \\\"bytes32 conduitKey,\\\",\\n \\\"uint256 counter\\\",\\n \\\")\\\"\\n );\\n\\n // Construct the primary EIP-712 domain type string.\\n // prettier-ignore\\n eip712DomainTypehash = keccak256(\\n abi.encodePacked(\\n \\\"EIP712Domain(\\\",\\n \\\"string name,\\\",\\n \\\"string version,\\\",\\n \\\"uint256 chainId,\\\",\\n \\\"address verifyingContract\\\",\\n \\\")\\\"\\n )\\n );\\n\\n // Derive the OfferItem type hash using the corresponding type string.\\n offerItemTypehash = keccak256(offerItemTypeString);\\n\\n // Derive ConsiderationItem type hash using corresponding type string.\\n considerationItemTypehash = keccak256(considerationItemTypeString);\\n\\n // Derive OrderItem type hash via combination of relevant type strings.\\n orderTypehash = keccak256(\\n abi.encodePacked(\\n orderComponentsPartialTypeString,\\n considerationItemTypeString,\\n offerItemTypeString\\n )\\n );\\n }\\n}\\n\",\"keccak256\":\"0x0cb8d945b571fb8445e01fe22e3674acc2a829feb21782f3aa30f88bf7fa454b\",\"license\":\"MIT\"},\"contracts/lib/ConsiderationConstants.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.7;\\n\\n/*\\n * -------------------------- Disambiguation & Other Notes ---------------------\\n * - The term \\\"head\\\" is used as it is in the documentation for ABI encoding,\\n * but only in reference to dynamic types, i.e. it always refers to the\\n * offset or pointer to the body of a dynamic type. In calldata, the head\\n * is always an offset (relative to the parent object), while in memory,\\n * the head is always the pointer to the body. More information found here:\\n * https://docs.soliditylang.org/en/v0.8.14/abi-spec.html#argument-encoding\\n * - Note that the length of an array is separate from and precedes the\\n * head of the array.\\n *\\n * - The term \\\"body\\\" is used in place of the term \\\"head\\\" used in the ABI\\n * documentation. It refers to the start of the data for a dynamic type,\\n * e.g. the first word of a struct or the first word of the first element\\n * in an array.\\n *\\n * - The term \\\"pointer\\\" is used to describe the absolute position of a value\\n * and never an offset relative to another value.\\n * - The suffix \\\"_ptr\\\" refers to a memory pointer.\\n * - The suffix \\\"_cdPtr\\\" refers to a calldata pointer.\\n *\\n * - The term \\\"offset\\\" is used to describe the position of a value relative\\n * to some parent value. For example, OrderParameters_conduit_offset is the\\n * offset to the \\\"conduit\\\" value in the OrderParameters struct relative to\\n * the start of the body.\\n * - Note: Offsets are used to derive pointers.\\n *\\n * - Some structs have pointers defined for all of their fields in this file.\\n * Lines which are commented out are fields that are not used in the\\n * codebase but have been left in for readability.\\n */\\n\\n// Declare constants for name, version, and reentrancy sentinel values.\\n\\n// Name is right padded, so it touches the length which is left padded. This\\n// enables writing both values at once. Length goes at byte 95 in memory, and\\n// name fills bytes 96-109, so both values can be written left-padded to 77.\\nuint256 constant NameLengthPtr = 77;\\nuint256 constant NameWithLength = 0x0d436F6E73696465726174696F6E;\\n\\nuint256 constant Version = 0x312e31;\\nuint256 constant Version_length = 3;\\nuint256 constant Version_shift = 0xe8;\\n\\nuint256 constant _NOT_ENTERED = 1;\\nuint256 constant _ENTERED = 2;\\n\\n// Common Offsets\\n// Offsets for identically positioned fields shared by:\\n// OfferItem, ConsiderationItem, SpentItem, ReceivedItem\\n\\nuint256 constant Common_token_offset = 0x20;\\nuint256 constant Common_identifier_offset = 0x40;\\nuint256 constant Common_amount_offset = 0x60;\\n\\nuint256 constant ReceivedItem_size = 0xa0;\\nuint256 constant ReceivedItem_amount_offset = 0x60;\\nuint256 constant ReceivedItem_recipient_offset = 0x80;\\n\\nuint256 constant ReceivedItem_CommonParams_size = 0x60;\\n\\nuint256 constant ConsiderationItem_recipient_offset = 0xa0;\\n// Store the same constant in an abbreviated format for a line length fix.\\nuint256 constant ConsiderItem_recipient_offset = 0xa0;\\n\\nuint256 constant Execution_offerer_offset = 0x20;\\nuint256 constant Execution_conduit_offset = 0x40;\\n\\nuint256 constant InvalidFulfillmentComponentData_error_signature = (\\n 0x7fda727900000000000000000000000000000000000000000000000000000000\\n);\\nuint256 constant InvalidFulfillmentComponentData_error_len = 0x04;\\n\\nuint256 constant Panic_error_signature = (\\n 0x4e487b7100000000000000000000000000000000000000000000000000000000\\n);\\nuint256 constant Panic_error_offset = 0x04;\\nuint256 constant Panic_error_length = 0x24;\\nuint256 constant Panic_arithmetic = 0x11;\\n\\nuint256 constant MissingItemAmount_error_signature = (\\n 0x91b3e51400000000000000000000000000000000000000000000000000000000\\n);\\nuint256 constant MissingItemAmount_error_len = 0x04;\\n\\nuint256 constant OrderParameters_offer_head_offset = 0x40;\\nuint256 constant OrderParameters_consideration_head_offset = 0x60;\\nuint256 constant OrderParameters_conduit_offset = 0x120;\\nuint256 constant OrderParameters_counter_offset = 0x140;\\n\\nuint256 constant Fulfillment_itemIndex_offset = 0x20;\\n\\nuint256 constant AdvancedOrder_numerator_offset = 0x20;\\n\\nuint256 constant AlmostOneWord = 0x1f;\\nuint256 constant OneWord = 0x20;\\nuint256 constant TwoWords = 0x40;\\nuint256 constant ThreeWords = 0x60;\\nuint256 constant FourWords = 0x80;\\nuint256 constant FiveWords = 0xa0;\\n\\nuint256 constant FreeMemoryPointerSlot = 0x40;\\nuint256 constant ZeroSlot = 0x60;\\nuint256 constant DefaultFreeMemoryPointer = 0x80;\\n\\nuint256 constant Slot0x80 = 0x80;\\nuint256 constant Slot0xA0 = 0xa0;\\n\\nuint256 constant BasicOrder_endAmount_cdPtr = 0x104;\\nuint256 constant BasicOrder_common_params_size = 0xa0;\\nuint256 constant BasicOrder_considerationHashesArray_ptr = 0x160;\\n\\nuint256 constant EIP712_Order_size = 0x180;\\nuint256 constant EIP712_OfferItem_size = 0xc0;\\nuint256 constant EIP712_ConsiderationItem_size = 0xe0;\\nuint256 constant AdditionalRecipients_size = 0x40;\\n\\nuint256 constant EIP712_DomainSeparator_offset = 0x02;\\nuint256 constant EIP712_OrderHash_offset = 0x22;\\nuint256 constant EIP712_DigestPayload_size = 0x42;\\n\\nuint256 constant receivedItemsHash_ptr = 0x60;\\n\\n/*\\n * Memory layout in _prepareBasicFulfillmentFromCalldata of\\n * data for OrderFulfilled\\n *\\n * event OrderFulfilled(\\n * bytes32 orderHash,\\n * address indexed offerer,\\n * address indexed zone,\\n * address fulfiller,\\n * SpentItem[] offer,\\n * > (itemType, token, id, amount)\\n * ReceivedItem[] consideration\\n * > (itemType, token, id, amount, recipient)\\n * )\\n *\\n * - 0x00: orderHash\\n * - 0x20: fulfiller\\n * - 0x40: offer offset (0x80)\\n * - 0x60: consideration offset (0x120)\\n * - 0x80: offer.length (1)\\n * - 0xa0: offerItemType\\n * - 0xc0: offerToken\\n * - 0xe0: offerIdentifier\\n * - 0x100: offerAmount\\n * - 0x120: consideration.length (1 + additionalRecipients.length)\\n * - 0x140: considerationItemType\\n * - 0x160: considerationToken\\n * - 0x180: considerationIdentifier\\n * - 0x1a0: considerationAmount\\n * - 0x1c0: considerationRecipient\\n * - ...\\n */\\n\\n// Minimum length of the OrderFulfilled event data.\\n// Must be added to the size of the ReceivedItem array for additionalRecipients\\n// (0xa0 * additionalRecipients.length) to calculate full size of the buffer.\\nuint256 constant OrderFulfilled_baseSize = 0x1e0;\\nuint256 constant OrderFulfilled_selector = (\\n 0x9d9af8e38d66c62e2c12f0225249fd9d721c54b83f48d9352c97c6cacdcb6f31\\n);\\n\\n// Minimum offset in memory to OrderFulfilled event data.\\n// Must be added to the size of the EIP712 hash array for additionalRecipients\\n// (32 * additionalRecipients.length) to calculate the pointer to event data.\\nuint256 constant OrderFulfilled_baseOffset = 0x180;\\nuint256 constant OrderFulfilled_consideration_length_baseOffset = 0x2a0;\\nuint256 constant OrderFulfilled_offer_length_baseOffset = 0x200;\\n\\n// uint256 constant OrderFulfilled_orderHash_offset = 0x00;\\nuint256 constant OrderFulfilled_fulfiller_offset = 0x20;\\nuint256 constant OrderFulfilled_offer_head_offset = 0x40;\\nuint256 constant OrderFulfilled_offer_body_offset = 0x80;\\nuint256 constant OrderFulfilled_consideration_head_offset = 0x60;\\nuint256 constant OrderFulfilled_consideration_body_offset = 0x120;\\n\\n// BasicOrderParameters\\nuint256 constant BasicOrder_parameters_cdPtr = 0x04;\\nuint256 constant BasicOrder_considerationToken_cdPtr = 0x24;\\n// uint256 constant BasicOrder_considerationIdentifier_cdPtr = 0x44;\\nuint256 constant BasicOrder_considerationAmount_cdPtr = 0x64;\\nuint256 constant BasicOrder_offerer_cdPtr = 0x84;\\nuint256 constant BasicOrder_zone_cdPtr = 0xa4;\\nuint256 constant BasicOrder_offerToken_cdPtr = 0xc4;\\n// uint256 constant BasicOrder_offerIdentifier_cdPtr = 0xe4;\\nuint256 constant BasicOrder_offerAmount_cdPtr = 0x104;\\nuint256 constant BasicOrder_basicOrderType_cdPtr = 0x124;\\nuint256 constant BasicOrder_startTime_cdPtr = 0x144;\\n// uint256 constant BasicOrder_endTime_cdPtr = 0x164;\\n// uint256 constant BasicOrder_zoneHash_cdPtr = 0x184;\\n// uint256 constant BasicOrder_salt_cdPtr = 0x1a4;\\nuint256 constant BasicOrder_offererConduit_cdPtr = 0x1c4;\\nuint256 constant BasicOrder_fulfillerConduit_cdPtr = 0x1e4;\\nuint256 constant BasicOrder_totalOriginalAdditionalRecipients_cdPtr = 0x204;\\nuint256 constant BasicOrder_additionalRecipients_head_cdPtr = 0x224;\\nuint256 constant BasicOrder_signature_cdPtr = 0x244;\\nuint256 constant BasicOrder_additionalRecipients_length_cdPtr = 0x264;\\nuint256 constant BasicOrder_additionalRecipients_data_cdPtr = 0x284;\\n\\nuint256 constant BasicOrder_parameters_ptr = 0x20;\\n\\nuint256 constant BasicOrder_basicOrderType_range = 0x18; // 24 values\\n\\n/*\\n * Memory layout in _prepareBasicFulfillmentFromCalldata of\\n * EIP712 data for ConsiderationItem\\n * - 0x80: ConsiderationItem EIP-712 typehash (constant)\\n * - 0xa0: itemType\\n * - 0xc0: token\\n * - 0xe0: identifier\\n * - 0x100: startAmount\\n * - 0x120: endAmount\\n * - 0x140: recipient\\n */\\nuint256 constant BasicOrder_considerationItem_typeHash_ptr = 0x80; // memoryPtr\\nuint256 constant BasicOrder_considerationItem_itemType_ptr = 0xa0;\\nuint256 constant BasicOrder_considerationItem_token_ptr = 0xc0;\\nuint256 constant BasicOrder_considerationItem_identifier_ptr = 0xe0;\\nuint256 constant BasicOrder_considerationItem_startAmount_ptr = 0x100;\\nuint256 constant BasicOrder_considerationItem_endAmount_ptr = 0x120;\\n// uint256 constant BasicOrder_considerationItem_recipient_ptr = 0x140;\\n\\n/*\\n * Memory layout in _prepareBasicFulfillmentFromCalldata of\\n * EIP712 data for OfferItem\\n * - 0x80: OfferItem EIP-712 typehash (constant)\\n * - 0xa0: itemType\\n * - 0xc0: token\\n * - 0xe0: identifier (reused for offeredItemsHash)\\n * - 0x100: startAmount\\n * - 0x120: endAmount\\n */\\nuint256 constant BasicOrder_offerItem_typeHash_ptr = DefaultFreeMemoryPointer;\\nuint256 constant BasicOrder_offerItem_itemType_ptr = 0xa0;\\nuint256 constant BasicOrder_offerItem_token_ptr = 0xc0;\\n// uint256 constant BasicOrder_offerItem_identifier_ptr = 0xe0;\\n// uint256 constant BasicOrder_offerItem_startAmount_ptr = 0x100;\\nuint256 constant BasicOrder_offerItem_endAmount_ptr = 0x120;\\n\\n/*\\n * Memory layout in _prepareBasicFulfillmentFromCalldata of\\n * EIP712 data for Order\\n * - 0x80: Order EIP-712 typehash (constant)\\n * - 0xa0: orderParameters.offerer\\n * - 0xc0: orderParameters.zone\\n * - 0xe0: keccak256(abi.encodePacked(offerHashes))\\n * - 0x100: keccak256(abi.encodePacked(considerationHashes))\\n * - 0x120: orderType\\n * - 0x140: startTime\\n * - 0x160: endTime\\n * - 0x180: zoneHash\\n * - 0x1a0: salt\\n * - 0x1c0: conduit\\n * - 0x1e0: _counters[orderParameters.offerer] (from storage)\\n */\\nuint256 constant BasicOrder_order_typeHash_ptr = 0x80;\\nuint256 constant BasicOrder_order_offerer_ptr = 0xa0;\\n// uint256 constant BasicOrder_order_zone_ptr = 0xc0;\\nuint256 constant BasicOrder_order_offerHashes_ptr = 0xe0;\\nuint256 constant BasicOrder_order_considerationHashes_ptr = 0x100;\\nuint256 constant BasicOrder_order_orderType_ptr = 0x120;\\nuint256 constant BasicOrder_order_startTime_ptr = 0x140;\\n// uint256 constant BasicOrder_order_endTime_ptr = 0x160;\\n// uint256 constant BasicOrder_order_zoneHash_ptr = 0x180;\\n// uint256 constant BasicOrder_order_salt_ptr = 0x1a0;\\n// uint256 constant BasicOrder_order_conduitKey_ptr = 0x1c0;\\nuint256 constant BasicOrder_order_counter_ptr = 0x1e0;\\nuint256 constant BasicOrder_additionalRecipients_head_ptr = 0x240;\\nuint256 constant BasicOrder_signature_ptr = 0x260;\\n\\n// Signature-related\\nbytes32 constant EIP2098_allButHighestBitMask = (\\n 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\\n);\\nbytes32 constant ECDSA_twentySeventhAndTwentyEighthBytesSet = (\\n 0x0000000000000000000000000000000000000000000000000000000101000000\\n);\\nuint256 constant ECDSA_MaxLength = 65;\\nuint256 constant ECDSA_signature_s_offset = 0x40;\\nuint256 constant ECDSA_signature_v_offset = 0x60;\\n\\nbytes32 constant EIP1271_isValidSignature_selector = (\\n 0x1626ba7e00000000000000000000000000000000000000000000000000000000\\n);\\nuint256 constant EIP1271_isValidSignature_signatureHead_negativeOffset = 0x20;\\nuint256 constant EIP1271_isValidSignature_digest_negativeOffset = 0x40;\\nuint256 constant EIP1271_isValidSignature_selector_negativeOffset = 0x44;\\nuint256 constant EIP1271_isValidSignature_calldata_baseLength = 0x64;\\n\\nuint256 constant EIP1271_isValidSignature_signature_head_offset = 0x40;\\n\\n// abi.encodeWithSignature(\\\"NoContract(address)\\\")\\nuint256 constant NoContract_error_signature = (\\n 0x5f15d67200000000000000000000000000000000000000000000000000000000\\n);\\nuint256 constant NoContract_error_sig_ptr = 0x0;\\nuint256 constant NoContract_error_token_ptr = 0x4;\\nuint256 constant NoContract_error_length = 0x24; // 4 + 32 == 36\\n\\nuint256 constant EIP_712_PREFIX = (\\n 0x1901000000000000000000000000000000000000000000000000000000000000\\n);\\n\\nuint256 constant ExtraGasBuffer = 0x20;\\nuint256 constant CostPerWord = 3;\\nuint256 constant MemoryExpansionCoefficient = 0x200; // 512\\n\\nuint256 constant Create2AddressDerivation_ptr = 0x0b;\\nuint256 constant Create2AddressDerivation_length = 0x55;\\n\\nuint256 constant MaskOverByteTwelve = (\\n 0x0000000000000000000000ff0000000000000000000000000000000000000000\\n);\\n\\nuint256 constant MaskOverLastTwentyBytes = (\\n 0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff\\n);\\n\\nuint256 constant MaskOverFirstFourBytes = (\\n 0xffffffff00000000000000000000000000000000000000000000000000000000\\n);\\n\\nuint256 constant Conduit_execute_signature = (\\n 0x4ce34aa200000000000000000000000000000000000000000000000000000000\\n);\\n\\nuint256 constant MaxUint8 = 0xff;\\nuint256 constant MaxUint120 = 0xffffffffffffffffffffffffffffff;\\n\\nuint256 constant Conduit_execute_ConduitTransfer_ptr = 0x20;\\nuint256 constant Conduit_execute_ConduitTransfer_length = 0x01;\\n\\nuint256 constant Conduit_execute_ConduitTransfer_offset_ptr = 0x04;\\nuint256 constant Conduit_execute_ConduitTransfer_length_ptr = 0x24;\\nuint256 constant Conduit_execute_transferItemType_ptr = 0x44;\\nuint256 constant Conduit_execute_transferToken_ptr = 0x64;\\nuint256 constant Conduit_execute_transferFrom_ptr = 0x84;\\nuint256 constant Conduit_execute_transferTo_ptr = 0xa4;\\nuint256 constant Conduit_execute_transferIdentifier_ptr = 0xc4;\\nuint256 constant Conduit_execute_transferAmount_ptr = 0xe4;\\n\\nuint256 constant OneConduitExecute_size = 0x104;\\n\\n// Sentinel value to indicate that the conduit accumulator is not armed.\\nuint256 constant AccumulatorDisarmed = 0x20;\\nuint256 constant AccumulatorArmed = 0x40;\\nuint256 constant Accumulator_conduitKey_ptr = 0x20;\\nuint256 constant Accumulator_selector_ptr = 0x40;\\nuint256 constant Accumulator_array_offset_ptr = 0x44;\\nuint256 constant Accumulator_array_length_ptr = 0x64;\\n\\nuint256 constant Accumulator_itemSizeOffsetDifference = 0x3c;\\n\\nuint256 constant Accumulator_array_offset = 0x20;\\nuint256 constant Conduit_transferItem_size = 0xc0;\\nuint256 constant Conduit_transferItem_token_ptr = 0x20;\\nuint256 constant Conduit_transferItem_from_ptr = 0x40;\\nuint256 constant Conduit_transferItem_to_ptr = 0x60;\\nuint256 constant Conduit_transferItem_identifier_ptr = 0x80;\\nuint256 constant Conduit_transferItem_amount_ptr = 0xa0;\\n\\n// Declare constant for errors related to amount derivation.\\n// error InexactFraction() @ AmountDerivationErrors.sol\\nuint256 constant InexactFraction_error_signature = (\\n 0xc63cf08900000000000000000000000000000000000000000000000000000000\\n);\\nuint256 constant InexactFraction_error_len = 0x04;\\n\\n// Declare constant for errors related to signature verification.\\nuint256 constant Ecrecover_precompile = 1;\\nuint256 constant Ecrecover_args_size = 0x80;\\nuint256 constant Signature_lower_v = 27;\\n\\n// error BadSignatureV(uint8) @ SignatureVerificationErrors.sol\\nuint256 constant BadSignatureV_error_signature = (\\n 0x1f003d0a00000000000000000000000000000000000000000000000000000000\\n);\\nuint256 constant BadSignatureV_error_offset = 0x04;\\nuint256 constant BadSignatureV_error_length = 0x24;\\n\\n// error InvalidSigner() @ SignatureVerificationErrors.sol\\nuint256 constant InvalidSigner_error_signature = (\\n 0x815e1d6400000000000000000000000000000000000000000000000000000000\\n);\\nuint256 constant InvalidSigner_error_length = 0x04;\\n\\n// error InvalidSignature() @ SignatureVerificationErrors.sol\\nuint256 constant InvalidSignature_error_signature = (\\n 0x8baa579f00000000000000000000000000000000000000000000000000000000\\n);\\nuint256 constant InvalidSignature_error_length = 0x04;\\n\\n// error BadContractSignature() @ SignatureVerificationErrors.sol\\nuint256 constant BadContractSignature_error_signature = (\\n 0x4f7fb80d00000000000000000000000000000000000000000000000000000000\\n);\\nuint256 constant BadContractSignature_error_length = 0x04;\\n\\nuint256 constant NumBitsAfterSelector = 0xe0;\\n\\n// 69 is the lowest modulus for which the remainder\\n// of every selector other than the two match functions\\n// is greater than those of the match functions.\\nuint256 constant NonMatchSelector_MagicModulus = 69;\\n// Of the two match function selectors, the highest\\n// remainder modulo 69 is 29.\\nuint256 constant NonMatchSelector_MagicRemainder = 0x1d;\\n\",\"keccak256\":\"0x426725332e6da67d87e7c13b32ac0b07b504ffb5a500441a4872ee9b3d15a068\",\"license\":\"MIT\"},\"contracts/lib/ConsiderationEnums.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.7;\\n\\n// prettier-ignore\\nenum OrderType {\\n // 0: no partial fills, anyone can execute\\n FULL_OPEN,\\n\\n // 1: partial fills supported, anyone can execute\\n PARTIAL_OPEN,\\n\\n // 2: no partial fills, only offerer or zone can execute\\n FULL_RESTRICTED,\\n\\n // 3: partial fills supported, only offerer or zone can execute\\n PARTIAL_RESTRICTED\\n}\\n\\n// prettier-ignore\\nenum BasicOrderType {\\n // 0: no partial fills, anyone can execute\\n ETH_TO_ERC721_FULL_OPEN,\\n\\n // 1: partial fills supported, anyone can execute\\n ETH_TO_ERC721_PARTIAL_OPEN,\\n\\n // 2: no partial fills, only offerer or zone can execute\\n ETH_TO_ERC721_FULL_RESTRICTED,\\n\\n // 3: partial fills supported, only offerer or zone can execute\\n ETH_TO_ERC721_PARTIAL_RESTRICTED,\\n\\n // 4: no partial fills, anyone can execute\\n ETH_TO_ERC1155_FULL_OPEN,\\n\\n // 5: partial fills supported, anyone can execute\\n ETH_TO_ERC1155_PARTIAL_OPEN,\\n\\n // 6: no partial fills, only offerer or zone can execute\\n ETH_TO_ERC1155_FULL_RESTRICTED,\\n\\n // 7: partial fills supported, only offerer or zone can execute\\n ETH_TO_ERC1155_PARTIAL_RESTRICTED,\\n\\n // 8: no partial fills, anyone can execute\\n ERC20_TO_ERC721_FULL_OPEN,\\n\\n // 9: partial fills supported, anyone can execute\\n ERC20_TO_ERC721_PARTIAL_OPEN,\\n\\n // 10: no partial fills, only offerer or zone can execute\\n ERC20_TO_ERC721_FULL_RESTRICTED,\\n\\n // 11: partial fills supported, only offerer or zone can execute\\n ERC20_TO_ERC721_PARTIAL_RESTRICTED,\\n\\n // 12: no partial fills, anyone can execute\\n ERC20_TO_ERC1155_FULL_OPEN,\\n\\n // 13: partial fills supported, anyone can execute\\n ERC20_TO_ERC1155_PARTIAL_OPEN,\\n\\n // 14: no partial fills, only offerer or zone can execute\\n ERC20_TO_ERC1155_FULL_RESTRICTED,\\n\\n // 15: partial fills supported, only offerer or zone can execute\\n ERC20_TO_ERC1155_PARTIAL_RESTRICTED,\\n\\n // 16: no partial fills, anyone can execute\\n ERC721_TO_ERC20_FULL_OPEN,\\n\\n // 17: partial fills supported, anyone can execute\\n ERC721_TO_ERC20_PARTIAL_OPEN,\\n\\n // 18: no partial fills, only offerer or zone can execute\\n ERC721_TO_ERC20_FULL_RESTRICTED,\\n\\n // 19: partial fills supported, only offerer or zone can execute\\n ERC721_TO_ERC20_PARTIAL_RESTRICTED,\\n\\n // 20: no partial fills, anyone can execute\\n ERC1155_TO_ERC20_FULL_OPEN,\\n\\n // 21: partial fills supported, anyone can execute\\n ERC1155_TO_ERC20_PARTIAL_OPEN,\\n\\n // 22: no partial fills, only offerer or zone can execute\\n ERC1155_TO_ERC20_FULL_RESTRICTED,\\n\\n // 23: partial fills supported, only offerer or zone can execute\\n ERC1155_TO_ERC20_PARTIAL_RESTRICTED\\n}\\n\\n// prettier-ignore\\nenum BasicOrderRouteType {\\n // 0: provide Ether (or other native token) to receive offered ERC721 item.\\n ETH_TO_ERC721,\\n\\n // 1: provide Ether (or other native token) to receive offered ERC1155 item.\\n ETH_TO_ERC1155,\\n\\n // 2: provide ERC20 item to receive offered ERC721 item.\\n ERC20_TO_ERC721,\\n\\n // 3: provide ERC20 item to receive offered ERC1155 item.\\n ERC20_TO_ERC1155,\\n\\n // 4: provide ERC721 item to receive offered ERC20 item.\\n ERC721_TO_ERC20,\\n\\n // 5: provide ERC1155 item to receive offered ERC20 item.\\n ERC1155_TO_ERC20\\n}\\n\\n// prettier-ignore\\nenum ItemType {\\n // 0: ETH on mainnet, MATIC on polygon, etc.\\n NATIVE,\\n\\n // 1: ERC20 items (ERC777 and ERC20 analogues could also technically work)\\n ERC20,\\n\\n // 2: ERC721 items\\n ERC721,\\n\\n // 3: ERC1155 items\\n ERC1155,\\n\\n // 4: ERC721 items where a number of tokenIds are supported\\n ERC721_WITH_CRITERIA,\\n\\n // 5: ERC1155 items where a number of ids are supported\\n ERC1155_WITH_CRITERIA\\n}\\n\\n// prettier-ignore\\nenum Side {\\n // 0: Items that can be spent\\n OFFER,\\n\\n // 1: Items that must be received\\n CONSIDERATION\\n}\\n\",\"keccak256\":\"0x6ddfa4ee4f4ff2893298a7f0c28d7f5ad8655f342f5cc21473656c47de50bba5\",\"license\":\"MIT\"},\"contracts/lib/ConsiderationStructs.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.7;\\n\\n// prettier-ignore\\nimport {\\n OrderType,\\n BasicOrderType,\\n ItemType,\\n Side\\n} from \\\"./ConsiderationEnums.sol\\\";\\n\\n/**\\n * @dev An order contains eleven components: an offerer, a zone (or account that\\n * can cancel the order or restrict who can fulfill the order depending on\\n * the type), the order type (specifying partial fill support as well as\\n * restricted order status), the start and end time, a hash that will be\\n * provided to the zone when validating restricted orders, a salt, a key\\n * corresponding to a given conduit, a counter, and an arbitrary number of\\n * offer items that can be spent along with consideration items that must\\n * be received by their respective recipient.\\n */\\nstruct OrderComponents {\\n address offerer;\\n address zone;\\n OfferItem[] offer;\\n ConsiderationItem[] consideration;\\n OrderType orderType;\\n uint256 startTime;\\n uint256 endTime;\\n bytes32 zoneHash;\\n uint256 salt;\\n bytes32 conduitKey;\\n uint256 counter;\\n}\\n\\n/**\\n * @dev An offer item has five components: an item type (ETH or other native\\n * tokens, ERC20, ERC721, and ERC1155, as well as criteria-based ERC721 and\\n * ERC1155), a token address, a dual-purpose \\\"identifierOrCriteria\\\"\\n * component that will either represent a tokenId or a merkle root\\n * depending on the item type, and a start and end amount that support\\n * increasing or decreasing amounts over the duration of the respective\\n * order.\\n */\\nstruct OfferItem {\\n ItemType itemType;\\n address token;\\n uint256 identifierOrCriteria;\\n uint256 startAmount;\\n uint256 endAmount;\\n}\\n\\n/**\\n * @dev A consideration item has the same five components as an offer item and\\n * an additional sixth component designating the required recipient of the\\n * item.\\n */\\nstruct ConsiderationItem {\\n ItemType itemType;\\n address token;\\n uint256 identifierOrCriteria;\\n uint256 startAmount;\\n uint256 endAmount;\\n address payable recipient;\\n}\\n\\n/**\\n * @dev A spent item is translated from a utilized offer item and has four\\n * components: an item type (ETH or other native tokens, ERC20, ERC721, and\\n * ERC1155), a token address, a tokenId, and an amount.\\n */\\nstruct SpentItem {\\n ItemType itemType;\\n address token;\\n uint256 identifier;\\n uint256 amount;\\n}\\n\\n/**\\n * @dev A received item is translated from a utilized consideration item and has\\n * the same four components as a spent item, as well as an additional fifth\\n * component designating the required recipient of the item.\\n */\\nstruct ReceivedItem {\\n ItemType itemType;\\n address token;\\n uint256 identifier;\\n uint256 amount;\\n address payable recipient;\\n}\\n\\n/**\\n * @dev For basic orders involving ETH / native / ERC20 <=> ERC721 / ERC1155\\n * matching, a group of six functions may be called that only requires a\\n * subset of the usual order arguments. Note the use of a \\\"basicOrderType\\\"\\n * enum; this represents both the usual order type as well as the \\\"route\\\"\\n * of the basic order (a simple derivation function for the basic order\\n * type is `basicOrderType = orderType + (4 * basicOrderRoute)`.)\\n */\\nstruct BasicOrderParameters {\\n // calldata offset\\n address considerationToken; // 0x24\\n uint256 considerationIdentifier; // 0x44\\n uint256 considerationAmount; // 0x64\\n address payable offerer; // 0x84\\n address zone; // 0xa4\\n address offerToken; // 0xc4\\n uint256 offerIdentifier; // 0xe4\\n uint256 offerAmount; // 0x104\\n BasicOrderType basicOrderType; // 0x124\\n uint256 startTime; // 0x144\\n uint256 endTime; // 0x164\\n bytes32 zoneHash; // 0x184\\n uint256 salt; // 0x1a4\\n bytes32 offererConduitKey; // 0x1c4\\n bytes32 fulfillerConduitKey; // 0x1e4\\n uint256 totalOriginalAdditionalRecipients; // 0x204\\n AdditionalRecipient[] additionalRecipients; // 0x224\\n bytes signature; // 0x244\\n // Total length, excluding dynamic array data: 0x264 (580)\\n}\\n\\n/**\\n * @dev Basic orders can supply any number of additional recipients, with the\\n * implied assumption that they are supplied from the offered ETH (or other\\n * native token) or ERC20 token for the order.\\n */\\nstruct AdditionalRecipient {\\n uint256 amount;\\n address payable recipient;\\n}\\n\\n/**\\n * @dev The full set of order components, with the exception of the counter,\\n * must be supplied when fulfilling more sophisticated orders or groups of\\n * orders. The total number of original consideration items must also be\\n * supplied, as the caller may specify additional consideration items.\\n */\\nstruct OrderParameters {\\n address offerer; // 0x00\\n address zone; // 0x20\\n OfferItem[] offer; // 0x40\\n ConsiderationItem[] consideration; // 0x60\\n OrderType orderType; // 0x80\\n uint256 startTime; // 0xa0\\n uint256 endTime; // 0xc0\\n bytes32 zoneHash; // 0xe0\\n uint256 salt; // 0x100\\n bytes32 conduitKey; // 0x120\\n uint256 totalOriginalConsiderationItems; // 0x140\\n // offer.length // 0x160\\n}\\n\\n/**\\n * @dev Orders require a signature in addition to the other order parameters.\\n */\\nstruct Order {\\n OrderParameters parameters;\\n bytes signature;\\n}\\n\\n/**\\n * @dev Advanced orders include a numerator (i.e. a fraction to attempt to fill)\\n * and a denominator (the total size of the order) in addition to the\\n * signature and other order parameters. It also supports an optional field\\n * for supplying extra data; this data will be included in a staticcall to\\n * `isValidOrderIncludingExtraData` on the zone for the order if the order\\n * type is restricted and the offerer or zone are not the caller.\\n */\\nstruct AdvancedOrder {\\n OrderParameters parameters;\\n uint120 numerator;\\n uint120 denominator;\\n bytes signature;\\n bytes extraData;\\n}\\n\\n/**\\n * @dev Orders can be validated (either explicitly via `validate`, or as a\\n * consequence of a full or partial fill), specifically cancelled (they can\\n * also be cancelled in bulk via incrementing a per-zone counter), and\\n * partially or fully filled (with the fraction filled represented by a\\n * numerator and denominator).\\n */\\nstruct OrderStatus {\\n bool isValidated;\\n bool isCancelled;\\n uint120 numerator;\\n uint120 denominator;\\n}\\n\\n/**\\n * @dev A criteria resolver specifies an order, side (offer vs. consideration),\\n * and item index. It then provides a chosen identifier (i.e. tokenId)\\n * alongside a merkle proof demonstrating the identifier meets the required\\n * criteria.\\n */\\nstruct CriteriaResolver {\\n uint256 orderIndex;\\n Side side;\\n uint256 index;\\n uint256 identifier;\\n bytes32[] criteriaProof;\\n}\\n\\n/**\\n * @dev A fulfillment is applied to a group of orders. It decrements a series of\\n * offer and consideration items, then generates a single execution\\n * element. A given fulfillment can be applied to as many offer and\\n * consideration items as desired, but must contain at least one offer and\\n * at least one consideration that match. The fulfillment must also remain\\n * consistent on all key parameters across all offer items (same offerer,\\n * token, type, tokenId, and conduit preference) as well as across all\\n * consideration items (token, type, tokenId, and recipient).\\n */\\nstruct Fulfillment {\\n FulfillmentComponent[] offerComponents;\\n FulfillmentComponent[] considerationComponents;\\n}\\n\\n/**\\n * @dev Each fulfillment component contains one index referencing a specific\\n * order and another referencing a specific offer or consideration item.\\n */\\nstruct FulfillmentComponent {\\n uint256 orderIndex;\\n uint256 itemIndex;\\n}\\n\\n/**\\n * @dev An execution is triggered once all consideration items have been zeroed\\n * out. It sends the item in question from the offerer to the item's\\n * recipient, optionally sourcing approvals from either this contract\\n * directly or from the offerer's chosen conduit if one is specified. An\\n * execution is not provided as an argument, but rather is derived via\\n * orders, criteria resolvers, and fulfillments (where the total number of\\n * executions will be less than or equal to the total number of indicated\\n * fulfillments) and returned as part of `matchOrders`.\\n */\\nstruct Execution {\\n ReceivedItem item;\\n address offerer;\\n bytes32 conduitKey;\\n}\\n\",\"keccak256\":\"0x6f2a4c36c003053164bc491c1e5501d6e76478d83e4f88abd42ac9a81ca6dfeb\",\"license\":\"MIT\"},\"contracts/lib/CounterManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.13;\\n\\n// prettier-ignore\\nimport {\\n ConsiderationEventsAndErrors\\n} from \\\"../interfaces/ConsiderationEventsAndErrors.sol\\\";\\n\\nimport { ReentrancyGuard } from \\\"./ReentrancyGuard.sol\\\";\\n\\n/**\\n * @title CounterManager\\n * @author 0age\\n * @notice CounterManager contains a storage mapping and related functionality\\n * for retrieving and incrementing a per-offerer counter.\\n */\\ncontract CounterManager is ConsiderationEventsAndErrors, ReentrancyGuard {\\n // Only orders signed using an offerer's current counter are fulfillable.\\n mapping(address => uint256) private _counters;\\n\\n /**\\n * @dev Internal function to cancel all orders from a given offerer with a\\n * given zone in bulk by incrementing a counter. Note that only the\\n * offerer may increment the counter.\\n *\\n * @return newCounter The new counter.\\n */\\n function _incrementCounter() internal returns (uint256 newCounter) {\\n // Ensure that the reentrancy guard is not currently set.\\n _assertNonReentrant();\\n\\n // Skip overflow check as counter cannot be incremented that far.\\n unchecked {\\n // Increment current counter for the supplied offerer.\\n newCounter = ++_counters[msg.sender];\\n }\\n\\n // Emit an event containing the new counter.\\n emit CounterIncremented(newCounter, msg.sender);\\n }\\n\\n /**\\n * @dev Internal view function to retrieve the current counter for a given\\n * offerer.\\n *\\n * @param offerer The offerer in question.\\n *\\n * @return currentCounter The current counter.\\n */\\n function _getCounter(address offerer)\\n internal\\n view\\n returns (uint256 currentCounter)\\n {\\n // Return the counter for the supplied offerer.\\n currentCounter = _counters[offerer];\\n }\\n}\\n\",\"keccak256\":\"0x372394e71e78738150eb9186a3e0ef977f0ae0133ede0b732d48547e490528c0\",\"license\":\"MIT\"},\"contracts/lib/CriteriaResolution.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.13;\\n\\nimport { ItemType, Side } from \\\"./ConsiderationEnums.sol\\\";\\n\\n// prettier-ignore\\nimport {\\n OfferItem,\\n ConsiderationItem,\\n OrderParameters,\\n AdvancedOrder,\\n CriteriaResolver\\n} from \\\"./ConsiderationStructs.sol\\\";\\n\\nimport \\\"./ConsiderationConstants.sol\\\";\\n\\n// prettier-ignore\\nimport {\\n CriteriaResolutionErrors\\n} from \\\"../interfaces/CriteriaResolutionErrors.sol\\\";\\n\\n/**\\n * @title CriteriaResolution\\n * @author 0age\\n * @notice CriteriaResolution contains a collection of pure functions related to\\n * resolving criteria-based items.\\n */\\ncontract CriteriaResolution is CriteriaResolutionErrors {\\n /**\\n * @dev Internal pure function to apply criteria resolvers containing\\n * specific token identifiers and associated proofs to order items.\\n *\\n * @param advancedOrders The orders to apply criteria resolvers to.\\n * @param criteriaResolvers An array where each element contains a\\n * reference to a specific order as well as that\\n * order's offer or consideration, a token\\n * identifier, and a proof that the supplied token\\n * identifier is contained in the order's merkle\\n * root. Note that a root of zero indicates that\\n * any transferable token identifier is valid and\\n * that no proof needs to be supplied.\\n */\\n function _applyCriteriaResolvers(\\n AdvancedOrder[] memory advancedOrders,\\n CriteriaResolver[] memory criteriaResolvers\\n ) internal pure {\\n // Skip overflow checks as all for loops are indexed starting at zero.\\n unchecked {\\n // Retrieve length of criteria resolvers array and place on stack.\\n uint256 totalCriteriaResolvers = criteriaResolvers.length;\\n\\n // Retrieve length of orders array and place on stack.\\n uint256 totalAdvancedOrders = advancedOrders.length;\\n\\n // Iterate over each criteria resolver.\\n for (uint256 i = 0; i < totalCriteriaResolvers; ++i) {\\n // Retrieve the criteria resolver.\\n CriteriaResolver memory criteriaResolver = (\\n criteriaResolvers[i]\\n );\\n\\n // Read the order index from memory and place it on the stack.\\n uint256 orderIndex = criteriaResolver.orderIndex;\\n\\n // Ensure that the order index is in range.\\n if (orderIndex >= totalAdvancedOrders) {\\n revert OrderCriteriaResolverOutOfRange();\\n }\\n\\n // Skip criteria resolution for order if not fulfilled.\\n if (advancedOrders[orderIndex].numerator == 0) {\\n continue;\\n }\\n\\n // Retrieve the parameters for the order.\\n OrderParameters memory orderParameters = (\\n advancedOrders[orderIndex].parameters\\n );\\n\\n // Read component index from memory and place it on the stack.\\n uint256 componentIndex = criteriaResolver.index;\\n\\n // Declare values for item's type and criteria.\\n ItemType itemType;\\n uint256 identifierOrCriteria;\\n\\n // If the criteria resolver refers to an offer item...\\n if (criteriaResolver.side == Side.OFFER) {\\n // Retrieve the offer.\\n OfferItem[] memory offer = orderParameters.offer;\\n\\n // Ensure that the component index is in range.\\n if (componentIndex >= offer.length) {\\n revert OfferCriteriaResolverOutOfRange();\\n }\\n\\n // Retrieve relevant item using the component index.\\n OfferItem memory offerItem = offer[componentIndex];\\n\\n // Read item type and criteria from memory & place on stack.\\n itemType = offerItem.itemType;\\n identifierOrCriteria = offerItem.identifierOrCriteria;\\n\\n // Optimistically update item type to remove criteria usage.\\n // Use assembly to operate on ItemType enum as a number.\\n ItemType newItemType;\\n assembly {\\n // Item type 4 becomes 2 and item type 5 becomes 3.\\n newItemType := sub(3, eq(itemType, 4))\\n }\\n offerItem.itemType = newItemType;\\n\\n // Optimistically update identifier w/ supplied identifier.\\n offerItem.identifierOrCriteria = criteriaResolver\\n .identifier;\\n } else {\\n // Otherwise, the resolver refers to a consideration item.\\n ConsiderationItem[] memory consideration = (\\n orderParameters.consideration\\n );\\n\\n // Ensure that the component index is in range.\\n if (componentIndex >= consideration.length) {\\n revert ConsiderationCriteriaResolverOutOfRange();\\n }\\n\\n // Retrieve relevant item using order and component index.\\n ConsiderationItem memory considerationItem = (\\n consideration[componentIndex]\\n );\\n\\n // Read item type and criteria from memory & place on stack.\\n itemType = considerationItem.itemType;\\n identifierOrCriteria = (\\n considerationItem.identifierOrCriteria\\n );\\n\\n // Optimistically update item type to remove criteria usage.\\n // Use assembly to operate on ItemType enum as a number.\\n ItemType newItemType;\\n assembly {\\n // Item type 4 becomes 2 and item type 5 becomes 3.\\n newItemType := sub(3, eq(itemType, 4))\\n }\\n considerationItem.itemType = newItemType;\\n\\n // Optimistically update identifier w/ supplied identifier.\\n considerationItem.identifierOrCriteria = (\\n criteriaResolver.identifier\\n );\\n }\\n\\n // Ensure the specified item type indicates criteria usage.\\n if (!_isItemWithCriteria(itemType)) {\\n revert CriteriaNotEnabledForItem();\\n }\\n\\n // If criteria is not 0 (i.e. a collection-wide offer)...\\n if (identifierOrCriteria != uint256(0)) {\\n // Verify identifier inclusion in criteria root using proof.\\n _verifyProof(\\n criteriaResolver.identifier,\\n identifierOrCriteria,\\n criteriaResolver.criteriaProof\\n );\\n }\\n }\\n\\n // Iterate over each advanced order.\\n for (uint256 i = 0; i < totalAdvancedOrders; ++i) {\\n // Retrieve the advanced order.\\n AdvancedOrder memory advancedOrder = advancedOrders[i];\\n\\n // Skip criteria resolution for order if not fulfilled.\\n if (advancedOrder.numerator == 0) {\\n continue;\\n }\\n\\n // Retrieve the parameters for the order.\\n OrderParameters memory orderParameters = (\\n advancedOrder.parameters\\n );\\n\\n // Read consideration length from memory and place on stack.\\n uint256 totalItems = orderParameters.consideration.length;\\n\\n // Iterate over each consideration item on the order.\\n for (uint256 j = 0; j < totalItems; ++j) {\\n // Ensure item type no longer indicates criteria usage.\\n if (\\n _isItemWithCriteria(\\n orderParameters.consideration[j].itemType\\n )\\n ) {\\n revert UnresolvedConsiderationCriteria();\\n }\\n }\\n\\n // Read offer length from memory and place on stack.\\n totalItems = orderParameters.offer.length;\\n\\n // Iterate over each offer item on the order.\\n for (uint256 j = 0; j < totalItems; ++j) {\\n // Ensure item type no longer indicates criteria usage.\\n if (\\n _isItemWithCriteria(orderParameters.offer[j].itemType)\\n ) {\\n revert UnresolvedOfferCriteria();\\n }\\n }\\n }\\n }\\n }\\n\\n /**\\n * @dev Internal pure function to check whether a given item type represents\\n * a criteria-based ERC721 or ERC1155 item (e.g. an item that can be\\n * resolved to one of a number of different identifiers at the time of\\n * order fulfillment).\\n *\\n * @param itemType The item type in question.\\n *\\n * @return withCriteria A boolean indicating that the item type in question\\n * represents a criteria-based item.\\n */\\n function _isItemWithCriteria(ItemType itemType)\\n internal\\n pure\\n returns (bool withCriteria)\\n {\\n // ERC721WithCriteria is ItemType 4. ERC1155WithCriteria is ItemType 5.\\n assembly {\\n withCriteria := gt(itemType, 3)\\n }\\n }\\n\\n /**\\n * @dev Internal pure function to ensure that a given element is contained\\n * in a merkle root via a supplied proof.\\n *\\n * @param leaf The element for which to prove inclusion.\\n * @param root The merkle root that inclusion will be proved against.\\n * @param proof The merkle proof.\\n */\\n function _verifyProof(\\n uint256 leaf,\\n uint256 root,\\n bytes32[] memory proof\\n ) internal pure {\\n // Declare a variable that will be used to determine proof validity.\\n bool isValid;\\n\\n // Utilize assembly to efficiently verify the proof against the root.\\n assembly {\\n // Store the leaf at the beginning of scratch space.\\n mstore(0, leaf)\\n\\n // Derive the hash of the leaf to use as the initial proof element.\\n let computedHash := keccak256(0, OneWord)\\n\\n // Based on: https://github.com/Rari-Capital/solmate/blob/v7/src/utils/MerkleProof.sol\\n // Get memory start location of the first element in proof array.\\n let data := add(proof, OneWord)\\n\\n // Iterate over each proof element to compute the root hash.\\n for {\\n // Left shift by 5 is equivalent to multiplying by 0x20.\\n let end := add(data, shl(5, mload(proof)))\\n } lt(data, end) {\\n // Increment by one word at a time.\\n data := add(data, OneWord)\\n } {\\n // Get the proof element.\\n let loadedData := mload(data)\\n\\n // Sort proof elements and place them in scratch space.\\n // Slot of `computedHash` in scratch space.\\n // If the condition is true: 0x20, otherwise: 0x00.\\n let scratch := shl(5, gt(computedHash, loadedData))\\n\\n // Store elements to hash contiguously in scratch space. Scratch\\n // space is 64 bytes (0x00 - 0x3f) & both elements are 32 bytes.\\n mstore(scratch, computedHash)\\n mstore(xor(scratch, OneWord), loadedData)\\n\\n // Derive the updated hash.\\n computedHash := keccak256(0, TwoWords)\\n }\\n\\n // Compare the final hash to the supplied root.\\n isValid := eq(computedHash, root)\\n }\\n\\n // Revert if computed hash does not equal supplied root.\\n if (!isValid) {\\n revert InvalidProof();\\n }\\n }\\n}\\n\",\"keccak256\":\"0xca9b5e3d1e2aaeb50d7161ae922ef70837ad88c07feaddc249ccf3dd48fb40a5\",\"license\":\"MIT\"},\"contracts/lib/Executor.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.13;\\n\\nimport { ConduitInterface } from \\\"../interfaces/ConduitInterface.sol\\\";\\n\\nimport { ConduitItemType } from \\\"../conduit/lib/ConduitEnums.sol\\\";\\n\\nimport { ItemType } from \\\"./ConsiderationEnums.sol\\\";\\n\\nimport { ReceivedItem } from \\\"./ConsiderationStructs.sol\\\";\\n\\nimport { Verifiers } from \\\"./Verifiers.sol\\\";\\n\\nimport { TokenTransferrer } from \\\"./TokenTransferrer.sol\\\";\\n\\nimport \\\"./ConsiderationConstants.sol\\\";\\n\\n/**\\n * @title Executor\\n * @author 0age\\n * @notice Executor contains functions related to processing executions (i.e.\\n * transferring items, either directly or via conduits).\\n */\\ncontract Executor is Verifiers, TokenTransferrer {\\n /**\\n * @dev Derive and set hashes, reference chainId, and associated domain\\n * separator during deployment.\\n *\\n * @param conduitController A contract that deploys conduits, or proxies\\n * that may optionally be used to transfer approved\\n * ERC20/721/1155 tokens.\\n */\\n constructor(address conduitController) Verifiers(conduitController) {}\\n\\n /**\\n * @dev Internal function to transfer a given item, either directly or via\\n * a corresponding conduit.\\n *\\n * @param item The item to transfer, including an amount and a\\n * recipient.\\n * @param from The account supplying the item.\\n * @param conduitKey A bytes32 value indicating what corresponding conduit,\\n * if any, to source token approvals from. The zero hash\\n * signifies that no conduit should be used, with direct\\n * approvals set on this contract.\\n * @param accumulator An open-ended array that collects transfers to execute\\n * against a given conduit in a single call.\\n */\\n function _transfer(\\n ReceivedItem memory item,\\n address from,\\n bytes32 conduitKey,\\n bytes memory accumulator\\n ) internal {\\n // If the item type indicates Ether or a native token...\\n if (item.itemType == ItemType.NATIVE) {\\n // Ensure neither the token nor the identifier parameters are set.\\n if ((uint160(item.token) | item.identifier) != 0) {\\n revert UnusedItemParameters();\\n }\\n\\n // transfer the native tokens to the recipient.\\n _transferEth(item.recipient, item.amount);\\n } else if (item.itemType == ItemType.ERC20) {\\n // Ensure that no identifier is supplied.\\n if (item.identifier != 0) {\\n revert UnusedItemParameters();\\n }\\n\\n // Transfer ERC20 tokens from the source to the recipient.\\n _transferERC20(\\n item.token,\\n from,\\n item.recipient,\\n item.amount,\\n conduitKey,\\n accumulator\\n );\\n } else if (item.itemType == ItemType.ERC721) {\\n // Transfer ERC721 token from the source to the recipient.\\n _transferERC721(\\n item.token,\\n from,\\n item.recipient,\\n item.identifier,\\n item.amount,\\n conduitKey,\\n accumulator\\n );\\n } else {\\n // Transfer ERC1155 token from the source to the recipient.\\n _transferERC1155(\\n item.token,\\n from,\\n item.recipient,\\n item.identifier,\\n item.amount,\\n conduitKey,\\n accumulator\\n );\\n }\\n }\\n\\n /**\\n * @dev Internal function to transfer an individual ERC721 or ERC1155 item\\n * from a given originator to a given recipient. The accumulator will\\n * be bypassed, meaning that this function should be utilized in cases\\n * where multiple item transfers can be accumulated into a single\\n * conduit call. Sufficient approvals must be set, either on the\\n * respective conduit or on this contract itself.\\n *\\n * @param itemType The type of item to transfer, either ERC721 or ERC1155.\\n * @param token The token to transfer.\\n * @param from The originator of the transfer.\\n * @param to The recipient of the transfer.\\n * @param identifier The tokenId to transfer.\\n * @param amount The amount to transfer.\\n * @param conduitKey A bytes32 value indicating what corresponding conduit,\\n * if any, to source token approvals from. The zero hash\\n * signifies that no conduit should be used, with direct\\n * approvals set on this contract.\\n */\\n function _transferIndividual721Or1155Item(\\n ItemType itemType,\\n address token,\\n address from,\\n address to,\\n uint256 identifier,\\n uint256 amount,\\n bytes32 conduitKey\\n ) internal {\\n // Determine if the transfer is to be performed via a conduit.\\n if (conduitKey != bytes32(0)) {\\n // Use free memory pointer as calldata offset for the conduit call.\\n uint256 callDataOffset;\\n\\n // Utilize assembly to place each argument in free memory.\\n assembly {\\n // Retrieve the free memory pointer and use it as the offset.\\n callDataOffset := mload(FreeMemoryPointerSlot)\\n\\n // Write ConduitInterface.execute.selector to memory.\\n mstore(callDataOffset, Conduit_execute_signature)\\n\\n // Write the offset to the ConduitTransfer array in memory.\\n mstore(\\n add(\\n callDataOffset,\\n Conduit_execute_ConduitTransfer_offset_ptr\\n ),\\n Conduit_execute_ConduitTransfer_ptr\\n )\\n\\n // Write the length of the ConduitTransfer array to memory.\\n mstore(\\n add(\\n callDataOffset,\\n Conduit_execute_ConduitTransfer_length_ptr\\n ),\\n Conduit_execute_ConduitTransfer_length\\n )\\n\\n // Write the item type to memory.\\n mstore(\\n add(callDataOffset, Conduit_execute_transferItemType_ptr),\\n itemType\\n )\\n\\n // Write the token to memory.\\n mstore(\\n add(callDataOffset, Conduit_execute_transferToken_ptr),\\n token\\n )\\n\\n // Write the transfer source to memory.\\n mstore(\\n add(callDataOffset, Conduit_execute_transferFrom_ptr),\\n from\\n )\\n\\n // Write the transfer recipient to memory.\\n mstore(add(callDataOffset, Conduit_execute_transferTo_ptr), to)\\n\\n // Write the token identifier to memory.\\n mstore(\\n add(callDataOffset, Conduit_execute_transferIdentifier_ptr),\\n identifier\\n )\\n\\n // Write the transfer amount to memory.\\n mstore(\\n add(callDataOffset, Conduit_execute_transferAmount_ptr),\\n amount\\n )\\n }\\n\\n // Perform the call to the conduit.\\n _callConduitUsingOffsets(\\n conduitKey,\\n callDataOffset,\\n OneConduitExecute_size\\n );\\n } else {\\n // Otherwise, determine whether it is an ERC721 or ERC1155 item.\\n if (itemType == ItemType.ERC721) {\\n // Ensure that exactly one 721 item is being transferred.\\n if (amount != 1) {\\n revert InvalidERC721TransferAmount();\\n }\\n\\n // Perform transfer via the token contract directly.\\n _performERC721Transfer(token, from, to, identifier);\\n } else {\\n // Perform transfer via the token contract directly.\\n _performERC1155Transfer(token, from, to, identifier, amount);\\n }\\n }\\n }\\n\\n /**\\n * @dev Internal function to transfer Ether or other native tokens to a\\n * given recipient.\\n *\\n * @param to The recipient of the transfer.\\n * @param amount The amount to transfer.\\n */\\n function _transferEth(address payable to, uint256 amount) internal {\\n // Ensure that the supplied amount is non-zero.\\n _assertNonZeroAmount(amount);\\n\\n // Declare a variable indicating whether the call was successful or not.\\n bool success;\\n\\n assembly {\\n // Transfer the ETH and store if it succeeded or not.\\n success := call(gas(), to, amount, 0, 0, 0, 0)\\n }\\n\\n // If the call fails...\\n if (!success) {\\n // Revert and pass the revert reason along if one was returned.\\n _revertWithReasonIfOneIsReturned();\\n\\n // Otherwise, revert with a generic error message.\\n revert EtherTransferGenericFailure(to, amount);\\n }\\n }\\n\\n /**\\n * @dev Internal function to transfer ERC20 tokens from a given originator\\n * to a given recipient using a given conduit if applicable. Sufficient\\n * approvals must be set on this contract or on a respective conduit.\\n *\\n * @param token The ERC20 token to transfer.\\n * @param from The originator of the transfer.\\n * @param to The recipient of the transfer.\\n * @param amount The amount to transfer.\\n * @param conduitKey A bytes32 value indicating what corresponding conduit,\\n * if any, to source token approvals from. The zero hash\\n * signifies that no conduit should be used, with direct\\n * approvals set on this contract.\\n * @param accumulator An open-ended array that collects transfers to execute\\n * against a given conduit in a single call.\\n */\\n function _transferERC20(\\n address token,\\n address from,\\n address to,\\n uint256 amount,\\n bytes32 conduitKey,\\n bytes memory accumulator\\n ) internal {\\n // Ensure that the supplied amount is non-zero.\\n _assertNonZeroAmount(amount);\\n\\n // Trigger accumulated transfers if the conduits differ.\\n _triggerIfArmedAndNotAccumulatable(accumulator, conduitKey);\\n\\n // If no conduit has been specified...\\n if (conduitKey == bytes32(0)) {\\n // Perform the token transfer directly.\\n _performERC20Transfer(token, from, to, amount);\\n } else {\\n // Insert the call to the conduit into the accumulator.\\n _insert(\\n conduitKey,\\n accumulator,\\n ConduitItemType.ERC20,\\n token,\\n from,\\n to,\\n uint256(0),\\n amount\\n );\\n }\\n }\\n\\n /**\\n * @dev Internal function to transfer a single ERC721 token from a given\\n * originator to a given recipient. Sufficient approvals must be set,\\n * either on the respective conduit or on this contract itself.\\n *\\n * @param token The ERC721 token to transfer.\\n * @param from The originator of the transfer.\\n * @param to The recipient of the transfer.\\n * @param identifier The tokenId to transfer (must be 1 for ERC721).\\n * @param amount The amount to transfer.\\n * @param conduitKey A bytes32 value indicating what corresponding conduit,\\n * if any, to source token approvals from. The zero hash\\n * signifies that no conduit should be used, with direct\\n * approvals set on this contract.\\n * @param accumulator An open-ended array that collects transfers to execute\\n * against a given conduit in a single call.\\n */\\n function _transferERC721(\\n address token,\\n address from,\\n address to,\\n uint256 identifier,\\n uint256 amount,\\n bytes32 conduitKey,\\n bytes memory accumulator\\n ) internal {\\n // Trigger accumulated transfers if the conduits differ.\\n _triggerIfArmedAndNotAccumulatable(accumulator, conduitKey);\\n\\n // If no conduit has been specified...\\n if (conduitKey == bytes32(0)) {\\n // Ensure that exactly one 721 item is being transferred.\\n if (amount != 1) {\\n revert InvalidERC721TransferAmount();\\n }\\n\\n // Perform transfer via the token contract directly.\\n _performERC721Transfer(token, from, to, identifier);\\n } else {\\n // Insert the call to the conduit into the accumulator.\\n _insert(\\n conduitKey,\\n accumulator,\\n ConduitItemType.ERC721,\\n token,\\n from,\\n to,\\n identifier,\\n amount\\n );\\n }\\n }\\n\\n /**\\n * @dev Internal function to transfer ERC1155 tokens from a given originator\\n * to a given recipient. Sufficient approvals must be set, either on\\n * the respective conduit or on this contract itself.\\n *\\n * @param token The ERC1155 token to transfer.\\n * @param from The originator of the transfer.\\n * @param to The recipient of the transfer.\\n * @param identifier The id to transfer.\\n * @param amount The amount to transfer.\\n * @param conduitKey A bytes32 value indicating what corresponding conduit,\\n * if any, to source token approvals from. The zero hash\\n * signifies that no conduit should be used, with direct\\n * approvals set on this contract.\\n * @param accumulator An open-ended array that collects transfers to execute\\n * against a given conduit in a single call.\\n */\\n function _transferERC1155(\\n address token,\\n address from,\\n address to,\\n uint256 identifier,\\n uint256 amount,\\n bytes32 conduitKey,\\n bytes memory accumulator\\n ) internal {\\n // Ensure that the supplied amount is non-zero.\\n _assertNonZeroAmount(amount);\\n\\n // Trigger accumulated transfers if the conduits differ.\\n _triggerIfArmedAndNotAccumulatable(accumulator, conduitKey);\\n\\n // If no conduit has been specified...\\n if (conduitKey == bytes32(0)) {\\n // Perform transfer via the token contract directly.\\n _performERC1155Transfer(token, from, to, identifier, amount);\\n } else {\\n // Insert the call to the conduit into the accumulator.\\n _insert(\\n conduitKey,\\n accumulator,\\n ConduitItemType.ERC1155,\\n token,\\n from,\\n to,\\n identifier,\\n amount\\n );\\n }\\n }\\n\\n /**\\n * @dev Internal function to trigger a call to the conduit currently held by\\n * the accumulator if the accumulator contains item transfers (i.e. it\\n * is \\\"armed\\\") and the supplied conduit key does not match the key held\\n * by the accumulator.\\n *\\n * @param accumulator An open-ended array that collects transfers to execute\\n * against a given conduit in a single call.\\n * @param conduitKey A bytes32 value indicating what corresponding conduit,\\n * if any, to source token approvals from. The zero hash\\n * signifies that no conduit should be used, with direct\\n * approvals set on this contract.\\n */\\n function _triggerIfArmedAndNotAccumulatable(\\n bytes memory accumulator,\\n bytes32 conduitKey\\n ) internal {\\n // Retrieve the current conduit key from the accumulator.\\n bytes32 accumulatorConduitKey = _getAccumulatorConduitKey(accumulator);\\n\\n // Perform conduit call if the set key does not match the supplied key.\\n if (accumulatorConduitKey != conduitKey) {\\n _triggerIfArmed(accumulator);\\n }\\n }\\n\\n /**\\n * @dev Internal function to trigger a call to the conduit currently held by\\n * the accumulator if the accumulator contains item transfers (i.e. it\\n * is \\\"armed\\\").\\n *\\n * @param accumulator An open-ended array that collects transfers to execute\\n * against a given conduit in a single call.\\n */\\n function _triggerIfArmed(bytes memory accumulator) internal {\\n // Exit if the accumulator is not \\\"armed\\\".\\n if (accumulator.length != AccumulatorArmed) {\\n return;\\n }\\n\\n // Retrieve the current conduit key from the accumulator.\\n bytes32 accumulatorConduitKey = _getAccumulatorConduitKey(accumulator);\\n\\n // Perform conduit call.\\n _trigger(accumulatorConduitKey, accumulator);\\n }\\n\\n /**\\n * @dev Internal function to trigger a call to the conduit corresponding to\\n * a given conduit key, supplying all accumulated item transfers. The\\n * accumulator will be \\\"disarmed\\\" and reset in the process.\\n *\\n * @param conduitKey A bytes32 value indicating what corresponding conduit,\\n * if any, to source token approvals from. The zero hash\\n * signifies that no conduit should be used, with direct\\n * approvals set on this contract.\\n * @param accumulator An open-ended array that collects transfers to execute\\n * against a given conduit in a single call.\\n */\\n function _trigger(bytes32 conduitKey, bytes memory accumulator) internal {\\n // Declare variables for offset in memory & size of calldata to conduit.\\n uint256 callDataOffset;\\n uint256 callDataSize;\\n\\n // Call the conduit with all the accumulated transfers.\\n assembly {\\n // Call begins at third word; the first is length or \\\"armed\\\" status,\\n // and the second is the current conduit key.\\n callDataOffset := add(accumulator, TwoWords)\\n\\n // 68 + items * 192\\n callDataSize := add(\\n Accumulator_array_offset_ptr,\\n mul(\\n mload(add(accumulator, Accumulator_array_length_ptr)),\\n Conduit_transferItem_size\\n )\\n )\\n }\\n\\n // Call conduit derived from conduit key & supply accumulated transfers.\\n _callConduitUsingOffsets(conduitKey, callDataOffset, callDataSize);\\n\\n // Reset accumulator length to signal that it is now \\\"disarmed\\\".\\n assembly {\\n mstore(accumulator, AccumulatorDisarmed)\\n }\\n }\\n\\n /**\\n * @dev Internal function to perform a call to the conduit corresponding to\\n * a given conduit key based on the offset and size of the calldata in\\n * question in memory.\\n *\\n * @param conduitKey A bytes32 value indicating what corresponding\\n * conduit, if any, to source token approvals from.\\n * The zero hash signifies that no conduit should be\\n * used, with direct approvals set on this contract.\\n * @param callDataOffset The memory pointer where calldata is contained.\\n * @param callDataSize The size of calldata in memory.\\n */\\n function _callConduitUsingOffsets(\\n bytes32 conduitKey,\\n uint256 callDataOffset,\\n uint256 callDataSize\\n ) internal {\\n // Derive the address of the conduit using the conduit key.\\n address conduit = _deriveConduit(conduitKey);\\n\\n bool success;\\n bytes4 result;\\n\\n // call the conduit.\\n assembly {\\n // Ensure first word of scratch space is empty.\\n mstore(0, 0)\\n\\n // Perform call, placing first word of return data in scratch space.\\n success := call(\\n gas(),\\n conduit,\\n 0,\\n callDataOffset,\\n callDataSize,\\n 0,\\n OneWord\\n )\\n\\n // Take value from scratch space and place it on the stack.\\n result := mload(0)\\n }\\n\\n // If the call failed...\\n if (!success) {\\n // Pass along whatever revert reason was given by the conduit.\\n _revertWithReasonIfOneIsReturned();\\n\\n // Otherwise, revert with a generic error.\\n revert InvalidCallToConduit(conduit);\\n }\\n\\n // Ensure result was extracted and matches EIP-1271 magic value.\\n if (result != ConduitInterface.execute.selector) {\\n revert InvalidConduit(conduitKey, conduit);\\n }\\n }\\n\\n /**\\n * @dev Internal pure function to retrieve the current conduit key set for\\n * the accumulator.\\n *\\n * @param accumulator An open-ended array that collects transfers to execute\\n * against a given conduit in a single call.\\n *\\n * @return accumulatorConduitKey The conduit key currently set for the\\n * accumulator.\\n */\\n function _getAccumulatorConduitKey(bytes memory accumulator)\\n internal\\n pure\\n returns (bytes32 accumulatorConduitKey)\\n {\\n // Retrieve the current conduit key from the accumulator.\\n assembly {\\n accumulatorConduitKey := mload(\\n add(accumulator, Accumulator_conduitKey_ptr)\\n )\\n }\\n }\\n\\n /**\\n * @dev Internal pure function to place an item transfer into an accumulator\\n * that collects a series of transfers to execute against a given\\n * conduit in a single call.\\n *\\n * @param conduitKey A bytes32 value indicating what corresponding conduit,\\n * if any, to source token approvals from. The zero hash\\n * signifies that no conduit should be used, with direct\\n * approvals set on this contract.\\n * @param accumulator An open-ended array that collects transfers to execute\\n * against a given conduit in a single call.\\n * @param itemType The type of the item to transfer.\\n * @param token The token to transfer.\\n * @param from The originator of the transfer.\\n * @param to The recipient of the transfer.\\n * @param identifier The tokenId to transfer.\\n * @param amount The amount to transfer.\\n */\\n function _insert(\\n bytes32 conduitKey,\\n bytes memory accumulator,\\n ConduitItemType itemType,\\n address token,\\n address from,\\n address to,\\n uint256 identifier,\\n uint256 amount\\n ) internal pure {\\n uint256 elements;\\n // \\\"Arm\\\" and prime accumulator if it's not already armed. The sentinel\\n // value is held in the length of the accumulator array.\\n if (accumulator.length == AccumulatorDisarmed) {\\n elements = 1;\\n bytes4 selector = ConduitInterface.execute.selector;\\n assembly {\\n mstore(accumulator, AccumulatorArmed) // \\\"arm\\\" the accumulator.\\n mstore(add(accumulator, Accumulator_conduitKey_ptr), conduitKey)\\n mstore(add(accumulator, Accumulator_selector_ptr), selector)\\n mstore(\\n add(accumulator, Accumulator_array_offset_ptr),\\n Accumulator_array_offset\\n )\\n mstore(add(accumulator, Accumulator_array_length_ptr), elements)\\n }\\n } else {\\n // Otherwise, increase the number of elements by one.\\n assembly {\\n elements := add(\\n mload(add(accumulator, Accumulator_array_length_ptr)),\\n 1\\n )\\n mstore(add(accumulator, Accumulator_array_length_ptr), elements)\\n }\\n }\\n\\n // Insert the item.\\n assembly {\\n let itemPointer := sub(\\n add(accumulator, mul(elements, Conduit_transferItem_size)),\\n Accumulator_itemSizeOffsetDifference\\n )\\n mstore(itemPointer, itemType)\\n mstore(add(itemPointer, Conduit_transferItem_token_ptr), token)\\n mstore(add(itemPointer, Conduit_transferItem_from_ptr), from)\\n mstore(add(itemPointer, Conduit_transferItem_to_ptr), to)\\n mstore(\\n add(itemPointer, Conduit_transferItem_identifier_ptr),\\n identifier\\n )\\n mstore(add(itemPointer, Conduit_transferItem_amount_ptr), amount)\\n }\\n }\\n}\\n\",\"keccak256\":\"0x6ea2c9d0b30d0ebc52fc4fe3ad7cd23de55c15d10821294a769ceb4cb5667e38\",\"license\":\"MIT\"},\"contracts/lib/FulfillmentApplier.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.13;\\n\\nimport { ItemType, Side } from \\\"./ConsiderationEnums.sol\\\";\\n\\n// prettier-ignore\\nimport {\\n OfferItem,\\n ConsiderationItem,\\n ReceivedItem,\\n OrderParameters,\\n AdvancedOrder,\\n Execution,\\n FulfillmentComponent\\n} from \\\"./ConsiderationStructs.sol\\\";\\n\\nimport \\\"./ConsiderationConstants.sol\\\";\\n\\n// prettier-ignore\\nimport {\\n FulfillmentApplicationErrors\\n} from \\\"../interfaces/FulfillmentApplicationErrors.sol\\\";\\n\\n/**\\n * @title FulfillmentApplier\\n * @author 0age\\n * @notice FulfillmentApplier contains logic related to applying fulfillments,\\n * both as part of order matching (where offer items are matched to\\n * consideration items) as well as fulfilling available orders (where\\n * order items and consideration items are independently aggregated).\\n */\\ncontract FulfillmentApplier is FulfillmentApplicationErrors {\\n /**\\n * @dev Internal pure function to match offer items to consideration items\\n * on a group of orders via a supplied fulfillment.\\n *\\n * @param advancedOrders The orders to match.\\n * @param offerComponents An array designating offer components to\\n * match to consideration components.\\n * @param considerationComponents An array designating consideration\\n * components to match to offer components.\\n * Note that each consideration amount must\\n * be zero in order for the match operation\\n * to be valid.\\n *\\n * @return execution The transfer performed as a result of the fulfillment.\\n */\\n function _applyFulfillment(\\n AdvancedOrder[] memory advancedOrders,\\n FulfillmentComponent[] calldata offerComponents,\\n FulfillmentComponent[] calldata considerationComponents\\n ) internal pure returns (Execution memory execution) {\\n // Ensure 1+ of both offer and consideration components are supplied.\\n if (\\n offerComponents.length == 0 || considerationComponents.length == 0\\n ) {\\n revert OfferAndConsiderationRequiredOnFulfillment();\\n }\\n\\n // Declare a new Execution struct.\\n Execution memory considerationExecution;\\n\\n // Validate & aggregate consideration items to new Execution object.\\n _aggregateValidFulfillmentConsiderationItems(\\n advancedOrders,\\n considerationComponents,\\n considerationExecution\\n );\\n\\n // Retrieve the consideration item from the execution struct.\\n ReceivedItem memory considerationItem = considerationExecution.item;\\n\\n // Recipient does not need to be specified because it will always be set\\n // to that of the consideration.\\n // Validate & aggregate offer items to Execution object.\\n _aggregateValidFulfillmentOfferItems(\\n advancedOrders,\\n offerComponents,\\n execution\\n );\\n\\n // Ensure offer and consideration share types, tokens and identifiers.\\n if (\\n execution.item.itemType != considerationItem.itemType ||\\n execution.item.token != considerationItem.token ||\\n execution.item.identifier != considerationItem.identifier\\n ) {\\n revert MismatchedFulfillmentOfferAndConsiderationComponents();\\n }\\n\\n // If total consideration amount exceeds the offer amount...\\n if (considerationItem.amount > execution.item.amount) {\\n // Retrieve the first consideration component from the fulfillment.\\n FulfillmentComponent memory targetComponent = (\\n considerationComponents[0]\\n );\\n\\n // Skip underflow check as the conditional being true implies that\\n // considerationItem.amount > execution.item.amount.\\n unchecked {\\n // Add excess consideration item amount to original order array.\\n advancedOrders[targetComponent.orderIndex]\\n .parameters\\n .consideration[targetComponent.itemIndex]\\n .startAmount = (considerationItem.amount -\\n execution.item.amount);\\n }\\n\\n // Reduce total consideration amount to equal the offer amount.\\n considerationItem.amount = execution.item.amount;\\n } else {\\n // Retrieve the first offer component from the fulfillment.\\n FulfillmentComponent memory targetComponent = offerComponents[0];\\n\\n // Skip underflow check as the conditional being false implies that\\n // execution.item.amount >= considerationItem.amount.\\n unchecked {\\n // Add excess offer item amount to the original array of orders.\\n advancedOrders[targetComponent.orderIndex]\\n .parameters\\n .offer[targetComponent.itemIndex]\\n .startAmount = (execution.item.amount -\\n considerationItem.amount);\\n }\\n\\n // Reduce total offer amount to equal the consideration amount.\\n execution.item.amount = considerationItem.amount;\\n }\\n\\n // Reuse consideration recipient.\\n execution.item.recipient = considerationItem.recipient;\\n\\n // Return the final execution that will be triggered for relevant items.\\n return execution; // Execution(considerationItem, offerer, conduitKey);\\n }\\n\\n /**\\n * @dev Internal view function to aggregate offer or consideration items\\n * from a group of orders into a single execution via a supplied array\\n * of fulfillment components. Items that are not available to aggregate\\n * will not be included in the aggregated execution.\\n *\\n * @param advancedOrders The orders to aggregate.\\n * @param side The side (i.e. offer or consideration).\\n * @param fulfillmentComponents An array designating item components to\\n * aggregate if part of an available order.\\n * @param fulfillerConduitKey A bytes32 value indicating what conduit, if\\n * any, to source the fulfiller's token\\n * approvals from. The zero hash signifies that\\n * no conduit should be used, with approvals\\n * set directly on this contract.\\n * @param recipient The intended recipient for all received\\n * items.\\n *\\n * @return execution The transfer performed as a result of the fulfillment.\\n */\\n function _aggregateAvailable(\\n AdvancedOrder[] memory advancedOrders,\\n Side side,\\n FulfillmentComponent[] memory fulfillmentComponents,\\n bytes32 fulfillerConduitKey,\\n address recipient\\n ) internal view returns (Execution memory execution) {\\n // Skip overflow / underflow checks; conditions checked or unreachable.\\n unchecked {\\n // Retrieve fulfillment components array length and place on stack.\\n // Ensure at least one fulfillment component has been supplied.\\n if (fulfillmentComponents.length == 0) {\\n revert MissingFulfillmentComponentOnAggregation(side);\\n }\\n\\n // If the fulfillment components are offer components...\\n if (side == Side.OFFER) {\\n // Set the supplied recipient on the execution item.\\n execution.item.recipient = payable(recipient);\\n\\n // Return execution for aggregated items provided by offerer.\\n _aggregateValidFulfillmentOfferItems(\\n advancedOrders,\\n fulfillmentComponents,\\n execution\\n );\\n } else {\\n // Otherwise, fulfillment components are consideration\\n // components. Return execution for aggregated items provided by\\n // the fulfiller.\\n _aggregateValidFulfillmentConsiderationItems(\\n advancedOrders,\\n fulfillmentComponents,\\n execution\\n );\\n\\n // Set the caller as the offerer on the execution.\\n execution.offerer = msg.sender;\\n\\n // Set fulfiller conduit key as the conduit key on execution.\\n execution.conduitKey = fulfillerConduitKey;\\n }\\n\\n // Set the offerer and recipient to null address if execution\\n // amount is zero. This will cause the execution item to be skipped.\\n if (execution.item.amount == 0) {\\n execution.offerer = address(0);\\n execution.item.recipient = payable(0);\\n }\\n }\\n }\\n\\n /**\\n * @dev Internal pure function to aggregate a group of offer items using\\n * supplied directives on which component items are candidates for\\n * aggregation, skipping items on orders that are not available.\\n *\\n * @param advancedOrders The orders to aggregate offer items from.\\n * @param offerComponents An array of FulfillmentComponent structs\\n * indicating the order index and item index of each\\n * candidate offer item for aggregation.\\n * @param execution The execution to apply the aggregation to.\\n */\\n function _aggregateValidFulfillmentOfferItems(\\n AdvancedOrder[] memory advancedOrders,\\n FulfillmentComponent[] memory offerComponents,\\n Execution memory execution\\n ) internal pure {\\n assembly {\\n // Declare function for reverts on invalid fulfillment data.\\n function throwInvalidFulfillmentComponentData() {\\n // Store the InvalidFulfillmentComponentData error signature.\\n mstore(0, InvalidFulfillmentComponentData_error_signature)\\n\\n // Return, supplying InvalidFulfillmentComponentData signature.\\n revert(0, InvalidFulfillmentComponentData_error_len)\\n }\\n\\n // Declare function for reverts due to arithmetic overflows.\\n function throwOverflow() {\\n // Store the Panic error signature.\\n mstore(0, Panic_error_signature)\\n\\n // Store the arithmetic (0x11) panic code as initial argument.\\n mstore(Panic_error_offset, Panic_arithmetic)\\n\\n // Return, supplying Panic signature and arithmetic code.\\n revert(0, Panic_error_length)\\n }\\n\\n // Get position in offerComponents head.\\n let fulfillmentHeadPtr := add(offerComponents, OneWord)\\n\\n // Retrieve the order index using the fulfillment pointer.\\n let orderIndex := mload(mload(fulfillmentHeadPtr))\\n\\n // Ensure that the order index is not out of range.\\n if iszero(lt(orderIndex, mload(advancedOrders))) {\\n throwInvalidFulfillmentComponentData()\\n }\\n\\n // Read advancedOrders[orderIndex] pointer from its array head.\\n let orderPtr := mload(\\n // Calculate head position of advancedOrders[orderIndex].\\n add(add(advancedOrders, OneWord), mul(orderIndex, OneWord))\\n )\\n\\n // Read the pointer to OrderParameters from the AdvancedOrder.\\n let paramsPtr := mload(orderPtr)\\n\\n // Load the offer array pointer.\\n let offerArrPtr := mload(\\n add(paramsPtr, OrderParameters_offer_head_offset)\\n )\\n\\n // Retrieve item index using an offset of the fulfillment pointer.\\n let itemIndex := mload(\\n add(mload(fulfillmentHeadPtr), Fulfillment_itemIndex_offset)\\n )\\n\\n // Only continue if the fulfillment is not invalid.\\n if iszero(lt(itemIndex, mload(offerArrPtr))) {\\n throwInvalidFulfillmentComponentData()\\n }\\n\\n // Retrieve consideration item pointer using the item index.\\n let offerItemPtr := mload(\\n add(\\n // Get pointer to beginning of receivedItem.\\n add(offerArrPtr, OneWord),\\n // Calculate offset to pointer for desired order.\\n mul(itemIndex, OneWord)\\n )\\n )\\n\\n // Declare a variable for the final aggregated item amount.\\n let amount := 0\\n\\n // Create variable to track errors encountered with amount.\\n let errorBuffer := 0\\n\\n // Only add offer amount to execution amount on a nonzero numerator.\\n if mload(add(orderPtr, AdvancedOrder_numerator_offset)) {\\n // Retrieve amount pointer using consideration item pointer.\\n let amountPtr := add(offerItemPtr, Common_amount_offset)\\n\\n // Set the amount.\\n amount := mload(amountPtr)\\n\\n // Zero out amount on item to indicate it is credited.\\n mstore(amountPtr, 0)\\n\\n // Buffer indicating whether issues were found.\\n errorBuffer := iszero(amount)\\n }\\n\\n // Retrieve the received item pointer.\\n let receivedItemPtr := mload(execution)\\n\\n // Set the item type on the received item.\\n mstore(receivedItemPtr, mload(offerItemPtr))\\n\\n // Set the token on the received item.\\n mstore(\\n add(receivedItemPtr, Common_token_offset),\\n mload(add(offerItemPtr, Common_token_offset))\\n )\\n\\n // Set the identifier on the received item.\\n mstore(\\n add(receivedItemPtr, Common_identifier_offset),\\n mload(add(offerItemPtr, Common_identifier_offset))\\n )\\n\\n // Set the offerer on returned execution using order pointer.\\n mstore(add(execution, Execution_offerer_offset), mload(paramsPtr))\\n\\n // Set conduitKey on returned execution via offset of order pointer.\\n mstore(\\n add(execution, Execution_conduit_offset),\\n mload(add(paramsPtr, OrderParameters_conduit_offset))\\n )\\n\\n // Calculate the hash of (itemType, token, identifier).\\n let dataHash := keccak256(\\n receivedItemPtr,\\n ReceivedItem_CommonParams_size\\n )\\n\\n // Get position one word past last element in head of array.\\n let endPtr := add(\\n offerComponents,\\n mul(mload(offerComponents), OneWord)\\n )\\n\\n // Iterate over remaining offer components.\\n // prettier-ignore\\n for {} lt(fulfillmentHeadPtr, endPtr) {} {\\n // Increment the pointer to the fulfillment head by one word.\\n fulfillmentHeadPtr := add(fulfillmentHeadPtr, OneWord)\\n\\n // Get the order index using the fulfillment pointer.\\n orderIndex := mload(mload(fulfillmentHeadPtr))\\n\\n // Ensure the order index is in range.\\n if iszero(lt(orderIndex, mload(advancedOrders))) {\\n throwInvalidFulfillmentComponentData()\\n }\\n\\n // Get pointer to AdvancedOrder element.\\n orderPtr := mload(\\n add(\\n add(advancedOrders, OneWord),\\n mul(orderIndex, OneWord)\\n )\\n )\\n\\n // Only continue if numerator is not zero.\\n if iszero(mload(\\n add(orderPtr, AdvancedOrder_numerator_offset)\\n )) {\\n continue\\n }\\n\\n // Read the pointer to OrderParameters from the AdvancedOrder.\\n paramsPtr := mload(orderPtr)\\n\\n // Load offer array pointer.\\n offerArrPtr := mload(\\n add(\\n paramsPtr,\\n OrderParameters_offer_head_offset\\n )\\n )\\n\\n // Get the item index using the fulfillment pointer.\\n itemIndex := mload(add(mload(fulfillmentHeadPtr), OneWord))\\n\\n // Throw if itemIndex is out of the range of array.\\n if iszero(\\n lt(itemIndex, mload(offerArrPtr))\\n ) {\\n throwInvalidFulfillmentComponentData()\\n }\\n\\n // Retrieve offer item pointer using index.\\n offerItemPtr := mload(\\n add(\\n // Get pointer to beginning of receivedItem.\\n add(offerArrPtr, OneWord),\\n // Use offset to pointer for desired order.\\n mul(itemIndex, OneWord)\\n )\\n )\\n\\n // Retrieve amount pointer using offer item pointer.\\n let amountPtr := add(\\n offerItemPtr,\\n Common_amount_offset\\n )\\n\\n // Add offer amount to execution amount.\\n let newAmount := add(amount, mload(amountPtr))\\n\\n // Update error buffer: 1 = zero amount, 2 = overflow, 3 = both.\\n errorBuffer := or(\\n errorBuffer,\\n or(\\n shl(1, lt(newAmount, amount)),\\n iszero(mload(amountPtr))\\n )\\n )\\n\\n // Update the amount to the new, summed amount.\\n amount := newAmount\\n\\n // Zero out amount on original item to indicate it is credited.\\n mstore(amountPtr, 0)\\n\\n // Ensure the indicated item matches original item.\\n if iszero(\\n and(\\n and(\\n // The offerer must match on both items.\\n eq(\\n mload(paramsPtr),\\n mload(\\n add(execution, Execution_offerer_offset)\\n )\\n ),\\n // The conduit key must match on both items.\\n eq(\\n mload(\\n add(\\n paramsPtr,\\n OrderParameters_conduit_offset\\n )\\n ),\\n mload(\\n add(\\n execution,\\n Execution_conduit_offset\\n )\\n )\\n )\\n ),\\n // The itemType, token, and identifier must match.\\n eq(\\n dataHash,\\n keccak256(\\n offerItemPtr,\\n ReceivedItem_CommonParams_size\\n )\\n )\\n )\\n ) {\\n // Throw if any of the requirements are not met.\\n throwInvalidFulfillmentComponentData()\\n }\\n }\\n // Write final amount to execution.\\n mstore(add(mload(execution), Common_amount_offset), amount)\\n\\n // Determine whether the error buffer contains a nonzero error code.\\n if errorBuffer {\\n // If errorBuffer is 1, an item had an amount of zero.\\n if eq(errorBuffer, 1) {\\n // Store the MissingItemAmount error signature.\\n mstore(0, MissingItemAmount_error_signature)\\n\\n // Return, supplying MissingItemAmount signature.\\n revert(0, MissingItemAmount_error_len)\\n }\\n\\n // If errorBuffer is not 1 or 0, the sum overflowed.\\n // Panic!\\n throwOverflow()\\n }\\n }\\n }\\n\\n /**\\n * @dev Internal pure function to aggregate a group of consideration items\\n * using supplied directives on which component items are candidates\\n * for aggregation, skipping items on orders that are not available.\\n *\\n * @param advancedOrders The orders to aggregate consideration\\n * items from.\\n * @param considerationComponents An array of FulfillmentComponent structs\\n * indicating the order index and item index\\n * of each candidate consideration item for\\n * aggregation.\\n * @param execution The execution to apply the aggregation to.\\n */\\n function _aggregateValidFulfillmentConsiderationItems(\\n AdvancedOrder[] memory advancedOrders,\\n FulfillmentComponent[] memory considerationComponents,\\n Execution memory execution\\n ) internal pure {\\n // Utilize assembly in order to efficiently aggregate the items.\\n assembly {\\n // Declare function for reverts on invalid fulfillment data.\\n function throwInvalidFulfillmentComponentData() {\\n // Store the InvalidFulfillmentComponentData error signature.\\n mstore(0, InvalidFulfillmentComponentData_error_signature)\\n\\n // Return, supplying InvalidFulfillmentComponentData signature.\\n revert(0, InvalidFulfillmentComponentData_error_len)\\n }\\n\\n // Declare function for reverts due to arithmetic overflows.\\n function throwOverflow() {\\n // Store the Panic error signature.\\n mstore(0, Panic_error_signature)\\n\\n // Store the arithmetic (0x11) panic code as initial argument.\\n mstore(Panic_error_offset, Panic_arithmetic)\\n\\n // Return, supplying Panic signature and arithmetic code.\\n revert(0, Panic_error_length)\\n }\\n\\n // Get position in considerationComponents head.\\n let fulfillmentHeadPtr := add(considerationComponents, OneWord)\\n\\n // Retrieve the order index using the fulfillment pointer.\\n let orderIndex := mload(mload(fulfillmentHeadPtr))\\n\\n // Ensure that the order index is not out of range.\\n if iszero(lt(orderIndex, mload(advancedOrders))) {\\n throwInvalidFulfillmentComponentData()\\n }\\n\\n // Read advancedOrders[orderIndex] pointer from its array head.\\n let orderPtr := mload(\\n // Calculate head position of advancedOrders[orderIndex].\\n add(add(advancedOrders, OneWord), mul(orderIndex, OneWord))\\n )\\n\\n // Load consideration array pointer.\\n let considerationArrPtr := mload(\\n add(\\n // Read pointer to OrderParameters from the AdvancedOrder.\\n mload(orderPtr),\\n OrderParameters_consideration_head_offset\\n )\\n )\\n\\n // Retrieve item index using an offset of the fulfillment pointer.\\n let itemIndex := mload(\\n add(mload(fulfillmentHeadPtr), Fulfillment_itemIndex_offset)\\n )\\n\\n // Ensure that the order index is not out of range.\\n if iszero(lt(itemIndex, mload(considerationArrPtr))) {\\n throwInvalidFulfillmentComponentData()\\n }\\n\\n // Retrieve consideration item pointer using the item index.\\n let considerationItemPtr := mload(\\n add(\\n // Get pointer to beginning of receivedItem.\\n add(considerationArrPtr, OneWord),\\n // Calculate offset to pointer for desired order.\\n mul(itemIndex, OneWord)\\n )\\n )\\n\\n // Declare a variable for the final aggregated item amount.\\n let amount := 0\\n\\n // Create variable to track errors encountered with amount.\\n let errorBuffer := 0\\n\\n // Only add consideration amount to execution amount if numerator is\\n // greater than zero.\\n if mload(add(orderPtr, AdvancedOrder_numerator_offset)) {\\n // Retrieve amount pointer using consideration item pointer.\\n let amountPtr := add(considerationItemPtr, Common_amount_offset)\\n\\n // Set the amount.\\n amount := mload(amountPtr)\\n\\n // Set error bit if amount is zero.\\n errorBuffer := iszero(amount)\\n\\n // Zero out amount on item to indicate it is credited.\\n mstore(amountPtr, 0)\\n }\\n\\n // Retrieve ReceivedItem pointer from Execution.\\n let receivedItem := mload(execution)\\n\\n // Set the item type on the received item.\\n mstore(receivedItem, mload(considerationItemPtr))\\n\\n // Set the token on the received item.\\n mstore(\\n add(receivedItem, Common_token_offset),\\n mload(add(considerationItemPtr, Common_token_offset))\\n )\\n\\n // Set the identifier on the received item.\\n mstore(\\n add(receivedItem, Common_identifier_offset),\\n mload(add(considerationItemPtr, Common_identifier_offset))\\n )\\n\\n // Set the recipient on the received item.\\n mstore(\\n add(receivedItem, ReceivedItem_recipient_offset),\\n mload(\\n add(\\n considerationItemPtr,\\n ConsiderationItem_recipient_offset\\n )\\n )\\n )\\n\\n // Calculate the hash of (itemType, token, identifier).\\n let dataHash := keccak256(\\n receivedItem,\\n ReceivedItem_CommonParams_size\\n )\\n\\n // Get position one word past last element in head of array.\\n let endPtr := add(\\n considerationComponents,\\n mul(mload(considerationComponents), OneWord)\\n )\\n\\n // Iterate over remaining offer components.\\n // prettier-ignore\\n for {} lt(fulfillmentHeadPtr, endPtr) {} {\\n // Increment position in considerationComponents head.\\n fulfillmentHeadPtr := add(fulfillmentHeadPtr, OneWord)\\n\\n // Get the order index using the fulfillment pointer.\\n orderIndex := mload(mload(fulfillmentHeadPtr))\\n\\n // Ensure the order index is in range.\\n if iszero(lt(orderIndex, mload(advancedOrders))) {\\n throwInvalidFulfillmentComponentData()\\n }\\n\\n // Get pointer to AdvancedOrder element.\\n orderPtr := mload(\\n add(\\n add(advancedOrders, OneWord),\\n mul(orderIndex, OneWord)\\n )\\n )\\n\\n // Only continue if numerator is not zero.\\n if iszero(\\n mload(add(orderPtr, AdvancedOrder_numerator_offset))\\n ) {\\n continue\\n }\\n\\n // Load consideration array pointer from OrderParameters.\\n considerationArrPtr := mload(\\n add(\\n // Get pointer to OrderParameters from AdvancedOrder.\\n mload(orderPtr),\\n OrderParameters_consideration_head_offset\\n )\\n )\\n\\n // Get the item index using the fulfillment pointer.\\n itemIndex := mload(add(mload(fulfillmentHeadPtr), OneWord))\\n\\n // Check if itemIndex is within the range of array.\\n if iszero(lt(itemIndex, mload(considerationArrPtr))) {\\n throwInvalidFulfillmentComponentData()\\n }\\n\\n // Retrieve consideration item pointer using index.\\n considerationItemPtr := mload(\\n add(\\n // Get pointer to beginning of receivedItem.\\n add(considerationArrPtr, OneWord),\\n // Use offset to pointer for desired order.\\n mul(itemIndex, OneWord)\\n )\\n )\\n\\n // Retrieve amount pointer using consideration item pointer.\\n let amountPtr := add(\\n considerationItemPtr,\\n Common_amount_offset\\n )\\n\\n // Add offer amount to execution amount.\\n let newAmount := add(amount, mload(amountPtr))\\n\\n // Update error buffer: 1 = zero amount, 2 = overflow, 3 = both.\\n errorBuffer := or(\\n errorBuffer,\\n or(\\n shl(1, lt(newAmount, amount)),\\n iszero(mload(amountPtr))\\n )\\n )\\n\\n // Update the amount to the new, summed amount.\\n amount := newAmount\\n\\n // Zero out amount on original item to indicate it is credited.\\n mstore(amountPtr, 0)\\n\\n // Ensure the indicated item matches original item.\\n if iszero(\\n and(\\n // Item recipients must match.\\n eq(\\n mload(\\n add(\\n considerationItemPtr,\\n ConsiderItem_recipient_offset\\n )\\n ),\\n mload(\\n add(\\n receivedItem,\\n ReceivedItem_recipient_offset\\n )\\n )\\n ),\\n // The itemType, token, identifier must match.\\n eq(\\n dataHash,\\n keccak256(\\n considerationItemPtr,\\n ReceivedItem_CommonParams_size\\n )\\n )\\n )\\n ) {\\n // Throw if any of the requirements are not met.\\n throwInvalidFulfillmentComponentData()\\n }\\n }\\n // Write final amount to execution.\\n mstore(add(receivedItem, Common_amount_offset), amount)\\n\\n // Determine whether the error buffer contains a nonzero error code.\\n if errorBuffer {\\n // If errorBuffer is 1, an item had an amount of zero.\\n if eq(errorBuffer, 1) {\\n // Store the MissingItemAmount error signature.\\n mstore(0, MissingItemAmount_error_signature)\\n\\n // Return, supplying MissingItemAmount signature.\\n revert(0, MissingItemAmount_error_len)\\n }\\n\\n // If errorBuffer is not 1 or 0, the sum overflowed.\\n // Panic!\\n throwOverflow()\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x6f981470c1bd15baf8b616397550a8823fda56550f550dcbee995061d24eed3e\",\"license\":\"MIT\"},\"contracts/lib/GettersAndDerivers.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.13;\\n\\nimport { OrderParameters } from \\\"./ConsiderationStructs.sol\\\";\\n\\nimport { ConsiderationBase } from \\\"./ConsiderationBase.sol\\\";\\n\\nimport \\\"./ConsiderationConstants.sol\\\";\\n\\n/**\\n * @title GettersAndDerivers\\n * @author 0age\\n * @notice ConsiderationInternal contains pure and internal view functions\\n * related to getting or deriving various values.\\n */\\ncontract GettersAndDerivers is ConsiderationBase {\\n /**\\n * @dev Derive and set hashes, reference chainId, and associated domain\\n * separator during deployment.\\n *\\n * @param conduitController A contract that deploys conduits, or proxies\\n * that may optionally be used to transfer approved\\n * ERC20/721/1155 tokens.\\n */\\n constructor(address conduitController)\\n ConsiderationBase(conduitController)\\n {}\\n\\n /**\\n * @dev Internal view function to derive the order hash for a given order.\\n * Note that only the original consideration items are included in the\\n * order hash, as additional consideration items may be supplied by the\\n * caller.\\n *\\n * @param orderParameters The parameters of the order to hash.\\n * @param counter The counter of the order to hash.\\n *\\n * @return orderHash The hash.\\n */\\n function _deriveOrderHash(\\n OrderParameters memory orderParameters,\\n uint256 counter\\n ) internal view returns (bytes32 orderHash) {\\n // Get length of original consideration array and place it on the stack.\\n uint256 originalConsiderationLength = (\\n orderParameters.totalOriginalConsiderationItems\\n );\\n\\n /*\\n * Memory layout for an array of structs (dynamic or not) is similar\\n * to ABI encoding of dynamic types, with a head segment followed by\\n * a data segment. The main difference is that the head of an element\\n * is a memory pointer rather than an offset.\\n */\\n\\n // Declare a variable for the derived hash of the offer array.\\n bytes32 offerHash;\\n\\n // Read offer item EIP-712 typehash from runtime code & place on stack.\\n bytes32 typeHash = _OFFER_ITEM_TYPEHASH;\\n\\n // Utilize assembly so that memory regions can be reused across hashes.\\n assembly {\\n // Retrieve the free memory pointer and place on the stack.\\n let hashArrPtr := mload(FreeMemoryPointerSlot)\\n\\n // Get the pointer to the offers array.\\n let offerArrPtr := mload(\\n add(orderParameters, OrderParameters_offer_head_offset)\\n )\\n\\n // Load the length.\\n let offerLength := mload(offerArrPtr)\\n\\n // Set the pointer to the first offer's head.\\n offerArrPtr := add(offerArrPtr, OneWord)\\n\\n // Iterate over the offer items.\\n // prettier-ignore\\n for { let i := 0 } lt(i, offerLength) {\\n i := add(i, 1)\\n } {\\n // Read the pointer to the offer data and subtract one word\\n // to get typeHash pointer.\\n let ptr := sub(mload(offerArrPtr), OneWord)\\n\\n // Read the current value before the offer data.\\n let value := mload(ptr)\\n\\n // Write the type hash to the previous word.\\n mstore(ptr, typeHash)\\n\\n // Take the EIP712 hash and store it in the hash array.\\n mstore(hashArrPtr, keccak256(ptr, EIP712_OfferItem_size))\\n\\n // Restore the previous word.\\n mstore(ptr, value)\\n\\n // Increment the array pointers by one word.\\n offerArrPtr := add(offerArrPtr, OneWord)\\n hashArrPtr := add(hashArrPtr, OneWord)\\n }\\n\\n // Derive the offer hash using the hashes of each item.\\n offerHash := keccak256(\\n mload(FreeMemoryPointerSlot),\\n mul(offerLength, OneWord)\\n )\\n }\\n\\n // Declare a variable for the derived hash of the consideration array.\\n bytes32 considerationHash;\\n\\n // Read consideration item typehash from runtime code & place on stack.\\n typeHash = _CONSIDERATION_ITEM_TYPEHASH;\\n\\n // Utilize assembly so that memory regions can be reused across hashes.\\n assembly {\\n // Retrieve the free memory pointer and place on the stack.\\n let hashArrPtr := mload(FreeMemoryPointerSlot)\\n\\n // Get the pointer to the consideration array.\\n let considerationArrPtr := add(\\n mload(\\n add(\\n orderParameters,\\n OrderParameters_consideration_head_offset\\n )\\n ),\\n OneWord\\n )\\n\\n // Iterate over the consideration items (not including tips).\\n // prettier-ignore\\n for { let i := 0 } lt(i, originalConsiderationLength) {\\n i := add(i, 1)\\n } {\\n // Read the pointer to the consideration data and subtract one\\n // word to get typeHash pointer.\\n let ptr := sub(mload(considerationArrPtr), OneWord)\\n\\n // Read the current value before the consideration data.\\n let value := mload(ptr)\\n\\n // Write the type hash to the previous word.\\n mstore(ptr, typeHash)\\n\\n // Take the EIP712 hash and store it in the hash array.\\n mstore(\\n hashArrPtr,\\n keccak256(ptr, EIP712_ConsiderationItem_size)\\n )\\n\\n // Restore the previous word.\\n mstore(ptr, value)\\n\\n // Increment the array pointers by one word.\\n considerationArrPtr := add(considerationArrPtr, OneWord)\\n hashArrPtr := add(hashArrPtr, OneWord)\\n }\\n\\n // Derive the consideration hash using the hashes of each item.\\n considerationHash := keccak256(\\n mload(FreeMemoryPointerSlot),\\n mul(originalConsiderationLength, OneWord)\\n )\\n }\\n\\n // Read order item EIP-712 typehash from runtime code & place on stack.\\n typeHash = _ORDER_TYPEHASH;\\n\\n // Utilize assembly to access derived hashes & other arguments directly.\\n assembly {\\n // Retrieve pointer to the region located just behind parameters.\\n let typeHashPtr := sub(orderParameters, OneWord)\\n\\n // Store the value at that pointer location to restore later.\\n let previousValue := mload(typeHashPtr)\\n\\n // Store the order item EIP-712 typehash at the typehash location.\\n mstore(typeHashPtr, typeHash)\\n\\n // Retrieve the pointer for the offer array head.\\n let offerHeadPtr := add(\\n orderParameters,\\n OrderParameters_offer_head_offset\\n )\\n\\n // Retrieve the data pointer referenced by the offer head.\\n let offerDataPtr := mload(offerHeadPtr)\\n\\n // Store the offer hash at the retrieved memory location.\\n mstore(offerHeadPtr, offerHash)\\n\\n // Retrieve the pointer for the consideration array head.\\n let considerationHeadPtr := add(\\n orderParameters,\\n OrderParameters_consideration_head_offset\\n )\\n\\n // Retrieve the data pointer referenced by the consideration head.\\n let considerationDataPtr := mload(considerationHeadPtr)\\n\\n // Store the consideration hash at the retrieved memory location.\\n mstore(considerationHeadPtr, considerationHash)\\n\\n // Retrieve the pointer for the counter.\\n let counterPtr := add(\\n orderParameters,\\n OrderParameters_counter_offset\\n )\\n\\n // Store the counter at the retrieved memory location.\\n mstore(counterPtr, counter)\\n\\n // Derive the order hash using the full range of order parameters.\\n orderHash := keccak256(typeHashPtr, EIP712_Order_size)\\n\\n // Restore the value previously held at typehash pointer location.\\n mstore(typeHashPtr, previousValue)\\n\\n // Restore offer data pointer at the offer head pointer location.\\n mstore(offerHeadPtr, offerDataPtr)\\n\\n // Restore consideration data pointer at the consideration head ptr.\\n mstore(considerationHeadPtr, considerationDataPtr)\\n\\n // Restore consideration item length at the counter pointer.\\n mstore(counterPtr, originalConsiderationLength)\\n }\\n }\\n\\n /**\\n * @dev Internal view function to derive the address of a given conduit\\n * using a corresponding conduit key.\\n *\\n * @param conduitKey A bytes32 value indicating what corresponding conduit,\\n * if any, to source token approvals from. This value is\\n * the \\\"salt\\\" parameter supplied by the deployer (i.e. the\\n * conduit controller) when deploying the given conduit.\\n *\\n * @return conduit The address of the conduit associated with the given\\n * conduit key.\\n */\\n function _deriveConduit(bytes32 conduitKey)\\n internal\\n view\\n returns (address conduit)\\n {\\n // Read conduit controller address from runtime and place on the stack.\\n address conduitController = address(_CONDUIT_CONTROLLER);\\n\\n // Read conduit creation code hash from runtime and place on the stack.\\n bytes32 conduitCreationCodeHash = _CONDUIT_CREATION_CODE_HASH;\\n\\n // Leverage scratch space to perform an efficient hash.\\n assembly {\\n // Retrieve the free memory pointer; it will be replaced afterwards.\\n let freeMemoryPointer := mload(FreeMemoryPointerSlot)\\n\\n // Place the control character and the conduit controller in scratch\\n // space; note that eleven bytes at the beginning are left unused.\\n mstore(0, or(MaskOverByteTwelve, conduitController))\\n\\n // Place the conduit key in the next region of scratch space.\\n mstore(OneWord, conduitKey)\\n\\n // Place conduit creation code hash in free memory pointer location.\\n mstore(TwoWords, conduitCreationCodeHash)\\n\\n // Derive conduit by hashing and applying a mask over last 20 bytes.\\n conduit := and(\\n // Hash the relevant region.\\n keccak256(\\n // The region starts at memory pointer 11.\\n Create2AddressDerivation_ptr,\\n // The region is 85 bytes long (1 + 20 + 32 + 32).\\n Create2AddressDerivation_length\\n ),\\n // The address equals the last twenty bytes of the hash.\\n MaskOverLastTwentyBytes\\n )\\n\\n // Restore the free memory pointer.\\n mstore(FreeMemoryPointerSlot, freeMemoryPointer)\\n }\\n }\\n\\n /**\\n * @dev Internal view function to get the EIP-712 domain separator. If the\\n * chainId matches the chainId set on deployment, the cached domain\\n * separator will be returned; otherwise, it will be derived from\\n * scratch.\\n *\\n * @return The domain separator.\\n */\\n function _domainSeparator() internal view returns (bytes32) {\\n // prettier-ignore\\n return block.chainid == _CHAIN_ID\\n ? _DOMAIN_SEPARATOR\\n : _deriveDomainSeparator();\\n }\\n\\n /**\\n * @dev Internal view function to retrieve configuration information for\\n * this contract.\\n *\\n * @return version The contract version.\\n * @return domainSeparator The domain separator for this contract.\\n * @return conduitController The conduit Controller set for this contract.\\n */\\n function _information()\\n internal\\n view\\n returns (\\n string memory version,\\n bytes32 domainSeparator,\\n address conduitController\\n )\\n {\\n // Derive the domain separator.\\n domainSeparator = _domainSeparator();\\n\\n // Declare variable as immutables cannot be accessed within assembly.\\n conduitController = address(_CONDUIT_CONTROLLER);\\n\\n // Allocate a string with the intended length.\\n version = new string(Version_length);\\n\\n // Set the version as data on the newly allocated string.\\n assembly {\\n mstore(add(version, OneWord), shl(Version_shift, Version))\\n }\\n }\\n\\n /**\\n * @dev Internal pure function to efficiently derive an digest to sign for\\n * an order in accordance with EIP-712.\\n *\\n * @param domainSeparator The domain separator.\\n * @param orderHash The order hash.\\n *\\n * @return value The hash.\\n */\\n function _deriveEIP712Digest(bytes32 domainSeparator, bytes32 orderHash)\\n internal\\n pure\\n returns (bytes32 value)\\n {\\n // Leverage scratch space to perform an efficient hash.\\n assembly {\\n // Place the EIP-712 prefix at the start of scratch space.\\n mstore(0, EIP_712_PREFIX)\\n\\n // Place the domain separator in the next region of scratch space.\\n mstore(EIP712_DomainSeparator_offset, domainSeparator)\\n\\n // Place the order hash in scratch space, spilling into the first\\n // two bytes of the free memory pointer \\u2014 this should never be set\\n // as memory cannot be expanded to that size, and will be zeroed out\\n // after the hash is performed.\\n mstore(EIP712_OrderHash_offset, orderHash)\\n\\n // Hash the relevant region (65 bytes).\\n value := keccak256(0, EIP712_DigestPayload_size)\\n\\n // Clear out the dirtied bits in the memory pointer.\\n mstore(EIP712_OrderHash_offset, 0)\\n }\\n }\\n}\\n\",\"keccak256\":\"0x67f3ab1b22d7e9b398d428b94e11fa9f11c0e93e22ff8d58c557031b1c557734\",\"license\":\"MIT\"},\"contracts/lib/LowLevelHelpers.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.13;\\n\\nimport \\\"./ConsiderationConstants.sol\\\";\\n\\n/**\\n * @title LowLevelHelpers\\n * @author 0age\\n * @notice LowLevelHelpers contains logic for performing various low-level\\n * operations.\\n */\\ncontract LowLevelHelpers {\\n /**\\n * @dev Internal view function to staticcall an arbitrary target with given\\n * calldata. Note that no data is written to memory and no contract\\n * size check is performed.\\n *\\n * @param target The account to staticcall.\\n * @param callData The calldata to supply when staticcalling the target.\\n *\\n * @return success The status of the staticcall to the target.\\n */\\n function _staticcall(address target, bytes memory callData)\\n internal\\n view\\n returns (bool success)\\n {\\n assembly {\\n // Perform the staticcall.\\n success := staticcall(\\n gas(),\\n target,\\n add(callData, OneWord),\\n mload(callData),\\n 0,\\n 0\\n )\\n }\\n }\\n\\n /**\\n * @dev Internal view function to revert and pass along the revert reason if\\n * data was returned by the last call and that the size of that data\\n * does not exceed the currently allocated memory size.\\n */\\n function _revertWithReasonIfOneIsReturned() internal view {\\n assembly {\\n // If it returned a message, bubble it up as long as sufficient gas\\n // remains to do so:\\n if returndatasize() {\\n // Ensure that sufficient gas is available to copy returndata\\n // while expanding memory where necessary. Start by computing\\n // the word size of returndata and allocated memory.\\n let returnDataWords := div(\\n add(returndatasize(), AlmostOneWord),\\n OneWord\\n )\\n\\n // Note: use the free memory pointer in place of msize() to work\\n // around a Yul warning that prevents accessing msize directly\\n // when the IR pipeline is activated.\\n let msizeWords := div(mload(FreeMemoryPointerSlot), OneWord)\\n\\n // Next, compute the cost of the returndatacopy.\\n let cost := mul(CostPerWord, returnDataWords)\\n\\n // Then, compute cost of new memory allocation.\\n if gt(returnDataWords, msizeWords) {\\n cost := add(\\n cost,\\n add(\\n mul(sub(returnDataWords, msizeWords), CostPerWord),\\n div(\\n sub(\\n mul(returnDataWords, returnDataWords),\\n mul(msizeWords, msizeWords)\\n ),\\n MemoryExpansionCoefficient\\n )\\n )\\n )\\n }\\n\\n // Finally, add a small constant and compare to gas remaining;\\n // bubble up the revert data if enough gas is still available.\\n if lt(add(cost, ExtraGasBuffer), gas()) {\\n // Copy returndata to memory; overwrite existing memory.\\n returndatacopy(0, 0, returndatasize())\\n\\n // Revert, specifying memory region with copied returndata.\\n revert(0, returndatasize())\\n }\\n }\\n }\\n }\\n\\n /**\\n * @dev Internal pure function to determine if the first word of returndata\\n * matches an expected magic value.\\n *\\n * @param expected The expected magic value.\\n *\\n * @return A boolean indicating whether the expected value matches the one\\n * located in the first word of returndata.\\n */\\n function _doesNotMatchMagic(bytes4 expected) internal pure returns (bool) {\\n // Declare a variable for the value held by the return data buffer.\\n bytes4 result;\\n\\n // Utilize assembly in order to read directly from returndata buffer.\\n assembly {\\n // Only put result on stack if return data is exactly one word.\\n if eq(returndatasize(), OneWord) {\\n // Copy the word directly from return data into scratch space.\\n returndatacopy(0, 0, OneWord)\\n\\n // Take value from scratch space and place it on the stack.\\n result := mload(0)\\n }\\n }\\n\\n // Return a boolean indicating whether expected and located value match.\\n return result != expected;\\n }\\n}\\n\",\"keccak256\":\"0x65e076b9f106289dd3f9fcbea509b149b4610cac90391cb30ff8d037d6ae71c5\",\"license\":\"MIT\"},\"contracts/lib/OrderCombiner.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.13;\\n\\nimport { Side, ItemType } from \\\"./ConsiderationEnums.sol\\\";\\n\\n// prettier-ignore\\nimport {\\n OfferItem,\\n ConsiderationItem,\\n ReceivedItem,\\n OrderParameters,\\n Fulfillment,\\n FulfillmentComponent,\\n Execution,\\n Order,\\n AdvancedOrder,\\n CriteriaResolver\\n} from \\\"./ConsiderationStructs.sol\\\";\\n\\nimport { OrderFulfiller } from \\\"./OrderFulfiller.sol\\\";\\n\\nimport { FulfillmentApplier } from \\\"./FulfillmentApplier.sol\\\";\\n\\nimport \\\"./ConsiderationConstants.sol\\\";\\n\\n/**\\n * @title OrderCombiner\\n * @author 0age\\n * @notice OrderCombiner contains logic for fulfilling combinations of orders,\\n * either by matching offer items to consideration items or by\\n * fulfilling orders where available.\\n */\\ncontract OrderCombiner is OrderFulfiller, FulfillmentApplier {\\n /**\\n * @dev Derive and set hashes, reference chainId, and associated domain\\n * separator during deployment.\\n *\\n * @param conduitController A contract that deploys conduits, or proxies\\n * that may optionally be used to transfer approved\\n * ERC20/721/1155 tokens.\\n */\\n constructor(address conduitController) OrderFulfiller(conduitController) {}\\n\\n /**\\n * @notice Internal function to attempt to fill a group of orders, fully or\\n * partially, with an arbitrary number of items for offer and\\n * consideration per order alongside criteria resolvers containing\\n * specific token identifiers and associated proofs. Any order that\\n * is not currently active, has already been fully filled, or has\\n * been cancelled will be omitted. Remaining offer and consideration\\n * items will then be aggregated where possible as indicated by the\\n * supplied offer and consideration component arrays and aggregated\\n * items will be transferred to the fulfiller or to each intended\\n * recipient, respectively. Note that a failing item transfer or an\\n * issue with order formatting will cause the entire batch to fail.\\n *\\n * @param advancedOrders The orders to fulfill along with the\\n * fraction of those orders to attempt to\\n * fill. Note that both the offerer and the\\n * fulfiller must first approve this\\n * contract (or a conduit if indicated by\\n * the order) to transfer any relevant\\n * tokens on their behalf and that\\n * contracts must implement\\n * `onERC1155Received` in order to receive\\n * ERC1155 tokens as consideration. Also\\n * note that all offer and consideration\\n * components must have no remainder after\\n * multiplication of the respective amount\\n * with the supplied fraction for an\\n * order's partial fill amount to be\\n * considered valid.\\n * @param criteriaResolvers An array where each element contains a\\n * reference to a specific offer or\\n * consideration, a token identifier, and a\\n * proof that the supplied token identifier\\n * is contained in the merkle root held by\\n * the item in question's criteria element.\\n * Note that an empty criteria indicates\\n * that any (transferable) token\\n * identifier on the token in question is\\n * valid and that no associated proof needs\\n * to be supplied.\\n * @param offerFulfillments An array of FulfillmentComponent arrays\\n * indicating which offer items to attempt\\n * to aggregate when preparing executions.\\n * @param considerationFulfillments An array of FulfillmentComponent arrays\\n * indicating which consideration items to\\n * attempt to aggregate when preparing\\n * executions.\\n * @param fulfillerConduitKey A bytes32 value indicating what conduit,\\n * if any, to source the fulfiller's token\\n * approvals from. The zero hash signifies\\n * that no conduit should be used (and\\n * direct approvals set on Consideration).\\n * @param recipient The intended recipient for all received\\n * items.\\n * @param maximumFulfilled The maximum number of orders to fulfill.\\n *\\n * @return availableOrders An array of booleans indicating if each order\\n * with an index corresponding to the index of the\\n * returned boolean was fulfillable or not.\\n * @return executions An array of elements indicating the sequence of\\n * transfers performed as part of matching the given\\n * orders.\\n */\\n function _fulfillAvailableAdvancedOrders(\\n AdvancedOrder[] memory advancedOrders,\\n CriteriaResolver[] memory criteriaResolvers,\\n FulfillmentComponent[][] calldata offerFulfillments,\\n FulfillmentComponent[][] calldata considerationFulfillments,\\n bytes32 fulfillerConduitKey,\\n address recipient,\\n uint256 maximumFulfilled\\n )\\n internal\\n returns (bool[] memory availableOrders, Execution[] memory executions)\\n {\\n // Validate orders, apply amounts, & determine if they utilize conduits.\\n _validateOrdersAndPrepareToFulfill(\\n advancedOrders,\\n criteriaResolvers,\\n false, // Signifies that invalid orders should NOT revert.\\n maximumFulfilled,\\n recipient\\n );\\n\\n // Aggregate used offer and consideration items and execute transfers.\\n (availableOrders, executions) = _executeAvailableFulfillments(\\n advancedOrders,\\n offerFulfillments,\\n considerationFulfillments,\\n fulfillerConduitKey,\\n recipient\\n );\\n\\n // Return order fulfillment details and executions.\\n return (availableOrders, executions);\\n }\\n\\n /**\\n * @dev Internal function to validate a group of orders, update their\\n * statuses, reduce amounts by their previously filled fractions, apply\\n * criteria resolvers, and emit OrderFulfilled events.\\n *\\n * @param advancedOrders The advanced orders to validate and reduce by\\n * their previously filled amounts.\\n * @param criteriaResolvers An array where each element contains a reference\\n * to a specific order as well as that order's\\n * offer or consideration, a token identifier, and\\n * a proof that the supplied token identifier is\\n * contained in the order's merkle root. Note that\\n * a root of zero indicates that any transferable\\n * token identifier is valid and that no proof\\n * needs to be supplied.\\n * @param revertOnInvalid A boolean indicating whether to revert on any\\n * order being invalid; setting this to false will\\n * instead cause the invalid order to be skipped.\\n * @param maximumFulfilled The maximum number of orders to fulfill.\\n * @param recipient The intended recipient for all received items.\\n */\\n function _validateOrdersAndPrepareToFulfill(\\n AdvancedOrder[] memory advancedOrders,\\n CriteriaResolver[] memory criteriaResolvers,\\n bool revertOnInvalid,\\n uint256 maximumFulfilled,\\n address recipient\\n ) internal {\\n // Ensure this function cannot be triggered during a reentrant call.\\n _setReentrancyGuard();\\n\\n // Read length of orders array and place on the stack.\\n uint256 totalOrders = advancedOrders.length;\\n\\n // Track the order hash for each order being fulfilled.\\n bytes32[] memory orderHashes = new bytes32[](totalOrders);\\n\\n // Override orderHashes length to zero after memory has been allocated.\\n assembly {\\n mstore(orderHashes, 0)\\n }\\n\\n // Declare an error buffer indicating status of any native offer items.\\n // {00} == 0 => In a match function, no native offer items: allow.\\n // {01} == 1 => In a match function, some native offer items: allow.\\n // {10} == 2 => Not in a match function, no native offer items: allow.\\n // {11} == 3 => Not in a match function, some native offer items: THROW.\\n uint256 invalidNativeOfferItemErrorBuffer;\\n\\n // Use assembly to set the value for the second bit of the error buffer.\\n assembly {\\n // Use the second bit of the error buffer to indicate whether the\\n // current function is not matchAdvancedOrders or matchOrders.\\n invalidNativeOfferItemErrorBuffer := shl(\\n 1,\\n gt(\\n // Take the remainder of the selector modulo a magic value.\\n mod(\\n shr(NumBitsAfterSelector, calldataload(0)),\\n NonMatchSelector_MagicModulus\\n ),\\n // Check if remainder is higher than the greatest remainder\\n // of the two match selectors modulo the magic value.\\n NonMatchSelector_MagicRemainder\\n )\\n )\\n }\\n\\n // Skip overflow checks as all for loops are indexed starting at zero.\\n unchecked {\\n // Iterate over each order.\\n for (uint256 i = 0; i < totalOrders; ++i) {\\n // Retrieve the current order.\\n AdvancedOrder memory advancedOrder = advancedOrders[i];\\n\\n // Determine if max number orders have already been fulfilled.\\n if (maximumFulfilled == 0) {\\n // Mark fill fraction as zero as the order will not be used.\\n advancedOrder.numerator = 0;\\n\\n // Update the length of the orderHashes array.\\n assembly {\\n mstore(orderHashes, add(i, 1))\\n }\\n\\n // Continue iterating through the remaining orders.\\n continue;\\n }\\n\\n // Validate it, update status, and determine fraction to fill.\\n (\\n bytes32 orderHash,\\n uint256 numerator,\\n uint256 denominator\\n ) = _validateOrderAndUpdateStatus(\\n advancedOrder,\\n criteriaResolvers,\\n revertOnInvalid,\\n orderHashes\\n );\\n\\n // Update the length of the orderHashes array.\\n assembly {\\n mstore(orderHashes, add(i, 1))\\n }\\n\\n // Do not track hash or adjust prices if order is not fulfilled.\\n if (numerator == 0) {\\n // Mark fill fraction as zero if the order is not fulfilled.\\n advancedOrder.numerator = 0;\\n\\n // Continue iterating through the remaining orders.\\n continue;\\n }\\n\\n // Otherwise, track the order hash in question.\\n orderHashes[i] = orderHash;\\n\\n // Decrement the number of fulfilled orders.\\n // Skip underflow check as the condition before\\n // implies that maximumFulfilled > 0.\\n maximumFulfilled--;\\n\\n // Place the start time for the order on the stack.\\n uint256 startTime = advancedOrder.parameters.startTime;\\n\\n // Place the end time for the order on the stack.\\n uint256 endTime = advancedOrder.parameters.endTime;\\n\\n // Retrieve array of offer items for the order in question.\\n OfferItem[] memory offer = advancedOrder.parameters.offer;\\n\\n // Read length of offer array and place on the stack.\\n uint256 totalOfferItems = offer.length;\\n\\n // Iterate over each offer item on the order.\\n for (uint256 j = 0; j < totalOfferItems; ++j) {\\n // Retrieve the offer item.\\n OfferItem memory offerItem = offer[j];\\n\\n assembly {\\n // If the offer item is for the native token, set the\\n // first bit of the error buffer to true.\\n invalidNativeOfferItemErrorBuffer := or(\\n invalidNativeOfferItemErrorBuffer,\\n iszero(mload(offerItem))\\n )\\n }\\n\\n // Apply order fill fraction to offer item end amount.\\n uint256 endAmount = _getFraction(\\n numerator,\\n denominator,\\n offerItem.endAmount\\n );\\n\\n // Reuse same fraction if start and end amounts are equal.\\n if (offerItem.startAmount == offerItem.endAmount) {\\n // Apply derived amount to both start and end amount.\\n offerItem.startAmount = endAmount;\\n } else {\\n // Apply order fill fraction to offer item start amount.\\n offerItem.startAmount = _getFraction(\\n numerator,\\n denominator,\\n offerItem.startAmount\\n );\\n }\\n\\n // Update end amount in memory to match the derived amount.\\n offerItem.endAmount = endAmount;\\n\\n // Adjust offer amount using current time; round down.\\n offerItem.startAmount = _locateCurrentAmount(\\n offerItem.startAmount,\\n offerItem.endAmount,\\n startTime,\\n endTime,\\n false // round down\\n );\\n }\\n\\n // Retrieve array of consideration items for order in question.\\n ConsiderationItem[] memory consideration = (\\n advancedOrder.parameters.consideration\\n );\\n\\n // Read length of consideration array and place on the stack.\\n uint256 totalConsiderationItems = consideration.length;\\n\\n // Iterate over each consideration item on the order.\\n for (uint256 j = 0; j < totalConsiderationItems; ++j) {\\n // Retrieve the consideration item.\\n ConsiderationItem memory considerationItem = (\\n consideration[j]\\n );\\n\\n // Apply fraction to consideration item end amount.\\n uint256 endAmount = _getFraction(\\n numerator,\\n denominator,\\n considerationItem.endAmount\\n );\\n\\n // Reuse same fraction if start and end amounts are equal.\\n if (\\n considerationItem.startAmount ==\\n considerationItem.endAmount\\n ) {\\n // Apply derived amount to both start and end amount.\\n considerationItem.startAmount = endAmount;\\n } else {\\n // Apply fraction to consideration item start amount.\\n considerationItem.startAmount = _getFraction(\\n numerator,\\n denominator,\\n considerationItem.startAmount\\n );\\n }\\n\\n // Update end amount in memory to match the derived amount.\\n considerationItem.endAmount = endAmount;\\n\\n // Adjust consideration amount using current time; round up.\\n considerationItem.startAmount = (\\n _locateCurrentAmount(\\n considerationItem.startAmount,\\n considerationItem.endAmount,\\n startTime,\\n endTime,\\n true // round up\\n )\\n );\\n\\n // Utilize assembly to manually \\\"shift\\\" the recipient value.\\n assembly {\\n // Write recipient to endAmount, as endAmount is not\\n // used from this point on and can be repurposed to fit\\n // the layout of a ReceivedItem.\\n mstore(\\n add(\\n considerationItem,\\n ReceivedItem_recipient_offset // old endAmount\\n ),\\n mload(\\n add(\\n considerationItem,\\n ConsiderationItem_recipient_offset\\n )\\n )\\n )\\n }\\n }\\n }\\n }\\n\\n // If the first bit is set, a native offer item was encountered. If the\\n // second bit is set in the error buffer, the current function is not\\n // matchOrders or matchAdvancedOrders. If the value is three, both the\\n // first and second bits were set; in that case, revert with an error.\\n if (invalidNativeOfferItemErrorBuffer == 3) {\\n revert InvalidNativeOfferItem();\\n }\\n\\n // Apply criteria resolvers to each order as applicable.\\n _applyCriteriaResolvers(advancedOrders, criteriaResolvers);\\n\\n // Emit an event for each order signifying that it has been fulfilled.\\n // Skip overflow checks as all for loops are indexed starting at zero.\\n unchecked {\\n // Iterate over each order.\\n for (uint256 i = 0; i < totalOrders; ++i) {\\n // Do not emit an event if no order hash is present.\\n if (orderHashes[i] == bytes32(0)) {\\n continue;\\n }\\n\\n // Retrieve parameters for the order in question.\\n OrderParameters memory orderParameters = (\\n advancedOrders[i].parameters\\n );\\n\\n // Emit an OrderFulfilled event.\\n _emitOrderFulfilledEvent(\\n orderHashes[i],\\n orderParameters.offerer,\\n orderParameters.zone,\\n recipient,\\n orderParameters.offer,\\n orderParameters.consideration\\n );\\n }\\n }\\n }\\n\\n /**\\n * @dev Internal function to fulfill a group of validated orders, fully or\\n * partially, with an arbitrary number of items for offer and\\n * consideration per order and to execute transfers. Any order that is\\n * not currently active, has already been fully filled, or has been\\n * cancelled will be omitted. Remaining offer and consideration items\\n * will then be aggregated where possible as indicated by the supplied\\n * offer and consideration component arrays and aggregated items will\\n * be transferred to the fulfiller or to each intended recipient,\\n * respectively. Note that a failing item transfer or an issue with\\n * order formatting will cause the entire batch to fail.\\n *\\n * @param advancedOrders The orders to fulfill along with the\\n * fraction of those orders to attempt to\\n * fill. Note that both the offerer and the\\n * fulfiller must first approve this\\n * contract (or the conduit if indicated by\\n * the order) to transfer any relevant\\n * tokens on their behalf and that\\n * contracts must implement\\n * `onERC1155Received` in order to receive\\n * ERC1155 tokens as consideration. Also\\n * note that all offer and consideration\\n * components must have no remainder after\\n * multiplication of the respective amount\\n * with the supplied fraction for an\\n * order's partial fill amount to be\\n * considered valid.\\n * @param offerFulfillments An array of FulfillmentComponent arrays\\n * indicating which offer items to attempt\\n * to aggregate when preparing executions.\\n * @param considerationFulfillments An array of FulfillmentComponent arrays\\n * indicating which consideration items to\\n * attempt to aggregate when preparing\\n * executions.\\n * @param fulfillerConduitKey A bytes32 value indicating what conduit,\\n * if any, to source the fulfiller's token\\n * approvals from. The zero hash signifies\\n * that no conduit should be used, with\\n * direct approvals set on Consideration.\\n * @param recipient The intended recipient for all received\\n * items.\\n *\\n * @return availableOrders An array of booleans indicating if each order\\n * with an index corresponding to the index of the\\n * returned boolean was fulfillable or not.\\n * @return executions An array of elements indicating the sequence of\\n * transfers performed as part of matching the given\\n * orders.\\n */\\n function _executeAvailableFulfillments(\\n AdvancedOrder[] memory advancedOrders,\\n FulfillmentComponent[][] memory offerFulfillments,\\n FulfillmentComponent[][] memory considerationFulfillments,\\n bytes32 fulfillerConduitKey,\\n address recipient\\n )\\n internal\\n returns (bool[] memory availableOrders, Execution[] memory executions)\\n {\\n // Retrieve length of offer fulfillments array and place on the stack.\\n uint256 totalOfferFulfillments = offerFulfillments.length;\\n\\n // Retrieve length of consideration fulfillments array & place on stack.\\n uint256 totalConsiderationFulfillments = (\\n considerationFulfillments.length\\n );\\n\\n // Allocate an execution for each offer and consideration fulfillment.\\n executions = new Execution[](\\n totalOfferFulfillments + totalConsiderationFulfillments\\n );\\n\\n // Skip overflow checks as all for loops are indexed starting at zero.\\n unchecked {\\n // Track number of filtered executions.\\n uint256 totalFilteredExecutions = 0;\\n\\n // Iterate over each offer fulfillment.\\n for (uint256 i = 0; i < totalOfferFulfillments; ++i) {\\n /// Retrieve the offer fulfillment components in question.\\n FulfillmentComponent[] memory components = (\\n offerFulfillments[i]\\n );\\n\\n // Derive aggregated execution corresponding with fulfillment.\\n Execution memory execution = _aggregateAvailable(\\n advancedOrders,\\n Side.OFFER,\\n components,\\n fulfillerConduitKey,\\n recipient\\n );\\n\\n // If offerer and recipient on the execution are the same...\\n if (execution.item.recipient == execution.offerer) {\\n // Increment total filtered executions.\\n ++totalFilteredExecutions;\\n } else {\\n // Otherwise, assign the execution to the executions array.\\n executions[i - totalFilteredExecutions] = execution;\\n }\\n }\\n\\n // Iterate over each consideration fulfillment.\\n for (uint256 i = 0; i < totalConsiderationFulfillments; ++i) {\\n /// Retrieve consideration fulfillment components in question.\\n FulfillmentComponent[] memory components = (\\n considerationFulfillments[i]\\n );\\n\\n // Derive aggregated execution corresponding with fulfillment.\\n Execution memory execution = _aggregateAvailable(\\n advancedOrders,\\n Side.CONSIDERATION,\\n components,\\n fulfillerConduitKey,\\n address(0) // unused\\n );\\n\\n // If offerer and recipient on the execution are the same...\\n if (execution.item.recipient == execution.offerer) {\\n // Increment total filtered executions.\\n ++totalFilteredExecutions;\\n } else {\\n // Otherwise, assign the execution to the executions array.\\n executions[\\n i + totalOfferFulfillments - totalFilteredExecutions\\n ] = execution;\\n }\\n }\\n\\n // If some number of executions have been filtered...\\n if (totalFilteredExecutions != 0) {\\n // reduce the total length of the executions array.\\n assembly {\\n mstore(\\n executions,\\n sub(mload(executions), totalFilteredExecutions)\\n )\\n }\\n }\\n }\\n\\n // Revert if no orders are available.\\n if (executions.length == 0) {\\n revert NoSpecifiedOrdersAvailable();\\n }\\n\\n // Perform final checks and return.\\n availableOrders = _performFinalChecksAndExecuteOrders(\\n advancedOrders,\\n executions\\n );\\n\\n return (availableOrders, executions);\\n }\\n\\n /**\\n * @dev Internal function to perform a final check that each consideration\\n * item for an arbitrary number of fulfilled orders has been met and to\\n * trigger associated executions, transferring the respective items.\\n *\\n * @param advancedOrders The orders to check and perform executions for.\\n * @param executions An array of elements indicating the sequence of\\n * transfers to perform when fulfilling the given\\n * orders.\\n *\\n * @return availableOrders An array of booleans indicating if each order\\n * with an index corresponding to the index of the\\n * returned boolean was fulfillable or not.\\n */\\n function _performFinalChecksAndExecuteOrders(\\n AdvancedOrder[] memory advancedOrders,\\n Execution[] memory executions\\n ) internal returns (bool[] memory availableOrders) {\\n // Retrieve the length of the advanced orders array and place on stack.\\n uint256 totalOrders = advancedOrders.length;\\n\\n // Initialize array for tracking available orders.\\n availableOrders = new bool[](totalOrders);\\n\\n // Skip overflow checks as all for loops are indexed starting at zero.\\n unchecked {\\n // Iterate over orders to ensure all considerations are met.\\n for (uint256 i = 0; i < totalOrders; ++i) {\\n // Retrieve the order in question.\\n AdvancedOrder memory advancedOrder = advancedOrders[i];\\n\\n // Skip consideration item checks for order if not fulfilled.\\n if (advancedOrder.numerator == 0) {\\n // Note: orders do not need to be marked as unavailable as a\\n // new memory region has been allocated. Review carefully if\\n // altering compiler version or managing memory manually.\\n continue;\\n }\\n\\n // Mark the order as available.\\n availableOrders[i] = true;\\n\\n // Retrieve consideration items to ensure they are fulfilled.\\n ConsiderationItem[] memory consideration = (\\n advancedOrder.parameters.consideration\\n );\\n\\n // Read length of consideration array and place on the stack.\\n uint256 totalConsiderationItems = consideration.length;\\n\\n // Iterate over each consideration item to ensure it is met.\\n for (uint256 j = 0; j < totalConsiderationItems; ++j) {\\n // Retrieve remaining amount on the consideration item.\\n uint256 unmetAmount = consideration[j].startAmount;\\n\\n // Revert if the remaining amount is not zero.\\n if (unmetAmount != 0) {\\n revert ConsiderationNotMet(i, j, unmetAmount);\\n }\\n }\\n }\\n }\\n\\n // Put ether value supplied by the caller on the stack.\\n uint256 etherRemaining = msg.value;\\n\\n // Initialize an accumulator array. From this point forward, no new\\n // memory regions can be safely allocated until the accumulator is no\\n // longer being utilized, as the accumulator operates in an open-ended\\n // fashion from this memory pointer; existing memory may still be\\n // accessed and modified, however.\\n bytes memory accumulator = new bytes(AccumulatorDisarmed);\\n\\n // Retrieve the length of the executions array and place on stack.\\n uint256 totalExecutions = executions.length;\\n\\n // Iterate over each execution.\\n for (uint256 i = 0; i < totalExecutions; ) {\\n // Retrieve the execution and the associated received item.\\n Execution memory execution = executions[i];\\n ReceivedItem memory item = execution.item;\\n\\n // If execution transfers native tokens, reduce value available.\\n if (item.itemType == ItemType.NATIVE) {\\n // Ensure that sufficient native tokens are still available.\\n if (item.amount > etherRemaining) {\\n revert InsufficientEtherSupplied();\\n }\\n\\n // Skip underflow check as amount is less than ether remaining.\\n unchecked {\\n etherRemaining -= item.amount;\\n }\\n }\\n\\n // Transfer the item specified by the execution.\\n _transfer(\\n item,\\n execution.offerer,\\n execution.conduitKey,\\n accumulator\\n );\\n\\n // Skip overflow check as for loop is indexed starting at zero.\\n unchecked {\\n ++i;\\n }\\n }\\n\\n // Trigger any remaining accumulated transfers via call to the conduit.\\n _triggerIfArmed(accumulator);\\n\\n // If any ether remains after fulfillments, return it to the caller.\\n if (etherRemaining != 0) {\\n _transferEth(payable(msg.sender), etherRemaining);\\n }\\n\\n // Clear the reentrancy guard.\\n _clearReentrancyGuard();\\n\\n // Return the array containing available orders.\\n return (availableOrders);\\n }\\n\\n /**\\n * @dev Internal function to match an arbitrary number of full or partial\\n * orders, each with an arbitrary number of items for offer and\\n * consideration, supplying criteria resolvers containing specific\\n * token identifiers and associated proofs as well as fulfillments\\n * allocating offer components to consideration components.\\n *\\n * @param advancedOrders The advanced orders to match. Note that both the\\n * offerer and fulfiller on each order must first\\n * approve this contract (or their conduit if\\n * indicated by the order) to transfer any relevant\\n * tokens on their behalf and each consideration\\n * recipient must implement `onERC1155Received` in\\n * order to receive ERC1155 tokens. Also note that\\n * the offer and consideration components for each\\n * order must have no remainder after multiplying\\n * the respective amount with the supplied fraction\\n * in order for the group of partial fills to be\\n * considered valid.\\n * @param criteriaResolvers An array where each element contains a reference\\n * to a specific order as well as that order's\\n * offer or consideration, a token identifier, and\\n * a proof that the supplied token identifier is\\n * contained in the order's merkle root. Note that\\n * an empty root indicates that any (transferable)\\n * token identifier is valid and that no associated\\n * proof needs to be supplied.\\n * @param fulfillments An array of elements allocating offer components\\n * to consideration components. Note that each\\n * consideration component must be fully met in\\n * order for the match operation to be valid.\\n *\\n * @return executions An array of elements indicating the sequence of\\n * transfers performed as part of matching the given\\n * orders.\\n */\\n function _matchAdvancedOrders(\\n AdvancedOrder[] memory advancedOrders,\\n CriteriaResolver[] memory criteriaResolvers,\\n Fulfillment[] calldata fulfillments\\n ) internal returns (Execution[] memory executions) {\\n // Validate orders, update order status, and determine item amounts.\\n _validateOrdersAndPrepareToFulfill(\\n advancedOrders,\\n criteriaResolvers,\\n true, // Signifies that invalid orders should revert.\\n advancedOrders.length,\\n address(0) // OrderFulfilled event has no recipient when matching.\\n );\\n\\n // Fulfill the orders using the supplied fulfillments.\\n return _fulfillAdvancedOrders(advancedOrders, fulfillments);\\n }\\n\\n /**\\n * @dev Internal function to fulfill an arbitrary number of orders, either\\n * full or partial, after validating, adjusting amounts, and applying\\n * criteria resolvers.\\n *\\n * @param advancedOrders The orders to match, including a fraction to\\n * attempt to fill for each order.\\n * @param fulfillments An array of elements allocating offer\\n * components to consideration components. Note\\n * that the final amount of each consideration\\n * component must be zero for a match operation to\\n * be considered valid.\\n *\\n * @return executions An array of elements indicating the sequence of\\n * transfers performed as part of matching the given\\n * orders.\\n */\\n function _fulfillAdvancedOrders(\\n AdvancedOrder[] memory advancedOrders,\\n Fulfillment[] calldata fulfillments\\n ) internal returns (Execution[] memory executions) {\\n // Retrieve fulfillments array length and place on the stack.\\n uint256 totalFulfillments = fulfillments.length;\\n\\n // Allocate executions by fulfillment and apply them to each execution.\\n executions = new Execution[](totalFulfillments);\\n\\n // Skip overflow checks as all for loops are indexed starting at zero.\\n unchecked {\\n // Track number of filtered executions.\\n uint256 totalFilteredExecutions = 0;\\n\\n // Iterate over each fulfillment.\\n for (uint256 i = 0; i < totalFulfillments; ++i) {\\n /// Retrieve the fulfillment in question.\\n Fulfillment calldata fulfillment = fulfillments[i];\\n\\n // Derive the execution corresponding with the fulfillment.\\n Execution memory execution = _applyFulfillment(\\n advancedOrders,\\n fulfillment.offerComponents,\\n fulfillment.considerationComponents\\n );\\n\\n // If offerer and recipient on the execution are the same...\\n if (execution.item.recipient == execution.offerer) {\\n // Increment total filtered executions.\\n ++totalFilteredExecutions;\\n } else {\\n // Otherwise, assign the execution to the executions array.\\n executions[i - totalFilteredExecutions] = execution;\\n }\\n }\\n\\n // If some number of executions have been filtered...\\n if (totalFilteredExecutions != 0) {\\n // reduce the total length of the executions array.\\n assembly {\\n mstore(\\n executions,\\n sub(mload(executions), totalFilteredExecutions)\\n )\\n }\\n }\\n }\\n\\n // Perform final checks and execute orders.\\n _performFinalChecksAndExecuteOrders(advancedOrders, executions);\\n\\n // Return the executions array.\\n return (executions);\\n }\\n}\\n\",\"keccak256\":\"0x7c107ec50902f122642804a3d4c5565a4e8f52847d87b248c29f5105bdb22c3e\",\"license\":\"MIT\"},\"contracts/lib/OrderFulfiller.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.13;\\n\\nimport { ItemType } from \\\"./ConsiderationEnums.sol\\\";\\n\\n// prettier-ignore\\nimport {\\n OfferItem,\\n ConsiderationItem,\\n SpentItem,\\n ReceivedItem,\\n OrderParameters,\\n Order,\\n AdvancedOrder,\\n CriteriaResolver\\n} from \\\"./ConsiderationStructs.sol\\\";\\n\\nimport { BasicOrderFulfiller } from \\\"./BasicOrderFulfiller.sol\\\";\\n\\nimport { CriteriaResolution } from \\\"./CriteriaResolution.sol\\\";\\n\\nimport { AmountDeriver } from \\\"./AmountDeriver.sol\\\";\\n\\nimport \\\"./ConsiderationConstants.sol\\\";\\n\\n/**\\n * @title OrderFulfiller\\n * @author 0age\\n * @notice OrderFulfiller contains logic related to order fulfillment where a\\n * single order is being fulfilled and where basic order fulfillment is\\n * not available as an option.\\n */\\ncontract OrderFulfiller is\\n BasicOrderFulfiller,\\n CriteriaResolution,\\n AmountDeriver\\n{\\n /**\\n * @dev Derive and set hashes, reference chainId, and associated domain\\n * separator during deployment.\\n *\\n * @param conduitController A contract that deploys conduits, or proxies\\n * that may optionally be used to transfer approved\\n * ERC20/721/1155 tokens.\\n */\\n constructor(address conduitController)\\n BasicOrderFulfiller(conduitController)\\n {}\\n\\n /**\\n * @dev Internal function to validate an order and update its status, adjust\\n * prices based on current time, apply criteria resolvers, determine\\n * what portion to fill, and transfer relevant tokens.\\n *\\n * @param advancedOrder The order to fulfill as well as the fraction\\n * to fill. Note that all offer and consideration\\n * components must divide with no remainder for\\n * the partial fill to be valid.\\n * @param criteriaResolvers An array where each element contains a\\n * reference to a specific offer or\\n * consideration, a token identifier, and a proof\\n * that the supplied token identifier is\\n * contained in the order's merkle root. Note\\n * that a criteria of zero indicates that any\\n * (transferable) token identifier is valid and\\n * that no proof needs to be supplied.\\n * @param fulfillerConduitKey A bytes32 value indicating what conduit, if\\n * any, to source the fulfiller's token approvals\\n * from. The zero hash signifies that no conduit\\n * should be used, with direct approvals set on\\n * Consideration.\\n * @param recipient The intended recipient for all received items.\\n *\\n * @return A boolean indicating whether the order has been fulfilled.\\n */\\n function _validateAndFulfillAdvancedOrder(\\n AdvancedOrder memory advancedOrder,\\n CriteriaResolver[] memory criteriaResolvers,\\n bytes32 fulfillerConduitKey,\\n address recipient\\n ) internal returns (bool) {\\n // Ensure this function cannot be triggered during a reentrant call.\\n _setReentrancyGuard();\\n\\n // Declare empty bytes32 array (unused, will remain empty).\\n bytes32[] memory priorOrderHashes;\\n\\n // Validate order, update status, and determine fraction to fill.\\n (\\n bytes32 orderHash,\\n uint256 fillNumerator,\\n uint256 fillDenominator\\n ) = _validateOrderAndUpdateStatus(\\n advancedOrder,\\n criteriaResolvers,\\n true,\\n priorOrderHashes\\n );\\n\\n // Create an array with length 1 containing the order.\\n AdvancedOrder[] memory advancedOrders = new AdvancedOrder[](1);\\n\\n // Populate the order as the first and only element of the new array.\\n advancedOrders[0] = advancedOrder;\\n\\n // Apply criteria resolvers using generated orders and details arrays.\\n _applyCriteriaResolvers(advancedOrders, criteriaResolvers);\\n\\n // Retrieve the order parameters after applying criteria resolvers.\\n OrderParameters memory orderParameters = advancedOrders[0].parameters;\\n\\n // Perform each item transfer with the appropriate fractional amount.\\n _applyFractionsAndTransferEach(\\n orderParameters,\\n fillNumerator,\\n fillDenominator,\\n fulfillerConduitKey,\\n recipient\\n );\\n\\n // Emit an event signifying that the order has been fulfilled.\\n _emitOrderFulfilledEvent(\\n orderHash,\\n orderParameters.offerer,\\n orderParameters.zone,\\n recipient,\\n orderParameters.offer,\\n orderParameters.consideration\\n );\\n\\n // Clear the reentrancy guard.\\n _clearReentrancyGuard();\\n\\n return true;\\n }\\n\\n /**\\n * @dev Internal function to transfer each item contained in a given single\\n * order fulfillment after applying a respective fraction to the amount\\n * being transferred.\\n *\\n * @param orderParameters The parameters for the fulfilled order.\\n * @param numerator A value indicating the portion of the order\\n * that should be filled.\\n * @param denominator A value indicating the total order size.\\n * @param fulfillerConduitKey A bytes32 value indicating what conduit, if\\n * any, to source the fulfiller's token approvals\\n * from. The zero hash signifies that no conduit\\n * should be used, with direct approvals set on\\n * Consideration.\\n * @param recipient The intended recipient for all received items.\\n */\\n function _applyFractionsAndTransferEach(\\n OrderParameters memory orderParameters,\\n uint256 numerator,\\n uint256 denominator,\\n bytes32 fulfillerConduitKey,\\n address recipient\\n ) internal {\\n // Read start time & end time from order parameters and place on stack.\\n uint256 startTime = orderParameters.startTime;\\n uint256 endTime = orderParameters.endTime;\\n\\n // Initialize an accumulator array. From this point forward, no new\\n // memory regions can be safely allocated until the accumulator is no\\n // longer being utilized, as the accumulator operates in an open-ended\\n // fashion from this memory pointer; existing memory may still be\\n // accessed and modified, however.\\n bytes memory accumulator = new bytes(AccumulatorDisarmed);\\n\\n // As of solidity 0.6.0, inline assembly cannot directly access function\\n // definitions, but can still access locally scoped function variables.\\n // This means that in order to recast the type of a function, we need to\\n // create a local variable to reference the internal function definition\\n // (using the same type) and a local variable with the desired type,\\n // and then cast the original function pointer to the desired type.\\n\\n /**\\n * Repurpose existing OfferItem memory regions on the offer array for\\n * the order by overriding the _transfer function pointer to accept a\\n * modified OfferItem argument in place of the usual ReceivedItem:\\n *\\n * ========= OfferItem ========== ====== ReceivedItem ======\\n * ItemType itemType; ------------> ItemType itemType;\\n * address token; ----------------> address token;\\n * uint256 identifierOrCriteria; -> uint256 identifier;\\n * uint256 startAmount; ----------> uint256 amount;\\n * uint256 endAmount; ------------> address recipient;\\n */\\n\\n // Declare a nested scope to minimize stack depth.\\n unchecked {\\n // Declare a virtual function pointer taking an OfferItem argument.\\n function(OfferItem memory, address, bytes32, bytes memory)\\n internal _transferOfferItem;\\n\\n {\\n // Assign _transfer function to a new function pointer (it takes\\n // a ReceivedItem as its initial argument)\\n function(ReceivedItem memory, address, bytes32, bytes memory)\\n internal _transferReceivedItem = _transfer;\\n\\n // Utilize assembly to override the virtual function pointer.\\n assembly {\\n // Cast initial ReceivedItem type to an OfferItem type.\\n _transferOfferItem := _transferReceivedItem\\n }\\n }\\n\\n // Read offer array length from memory and place on stack.\\n uint256 totalOfferItems = orderParameters.offer.length;\\n\\n // Iterate over each offer on the order.\\n // Skip overflow check as for loop is indexed starting at zero.\\n for (uint256 i = 0; i < totalOfferItems; ++i) {\\n // Retrieve the offer item.\\n OfferItem memory offerItem = orderParameters.offer[i];\\n\\n // Offer items for the native token can not be received\\n // outside of a match order function.\\n if (offerItem.itemType == ItemType.NATIVE) {\\n revert InvalidNativeOfferItem();\\n }\\n\\n // Declare an additional nested scope to minimize stack depth.\\n {\\n // Apply fill fraction to get offer item amount to transfer.\\n uint256 amount = _applyFraction(\\n offerItem.startAmount,\\n offerItem.endAmount,\\n numerator,\\n denominator,\\n startTime,\\n endTime,\\n false\\n );\\n\\n // Utilize assembly to set overloaded offerItem arguments.\\n assembly {\\n // Write new fractional amount to startAmount as amount.\\n mstore(\\n add(offerItem, ReceivedItem_amount_offset),\\n amount\\n )\\n\\n // Write recipient to endAmount.\\n mstore(\\n add(offerItem, ReceivedItem_recipient_offset),\\n recipient\\n )\\n }\\n }\\n\\n // Transfer the item from the offerer to the recipient.\\n _transferOfferItem(\\n offerItem,\\n orderParameters.offerer,\\n orderParameters.conduitKey,\\n accumulator\\n );\\n }\\n }\\n\\n // Put ether value supplied by the caller on the stack.\\n uint256 etherRemaining = msg.value;\\n\\n /**\\n * Repurpose existing ConsiderationItem memory regions on the\\n * consideration array for the order by overriding the _transfer\\n * function pointer to accept a modified ConsiderationItem argument in\\n * place of the usual ReceivedItem:\\n *\\n * ====== ConsiderationItem ===== ====== ReceivedItem ======\\n * ItemType itemType; ------------> ItemType itemType;\\n * address token; ----------------> address token;\\n * uint256 identifierOrCriteria;--> uint256 identifier;\\n * uint256 startAmount; ----------> uint256 amount;\\n * uint256 endAmount; /----> address recipient;\\n * address recipient; ------/\\n */\\n\\n // Declare a nested scope to minimize stack depth.\\n unchecked {\\n // Declare virtual function pointer with ConsiderationItem argument.\\n function(ConsiderationItem memory, address, bytes32, bytes memory)\\n internal _transferConsiderationItem;\\n {\\n // Reassign _transfer function to a new function pointer (it\\n // takes a ReceivedItem as its initial argument).\\n function(ReceivedItem memory, address, bytes32, bytes memory)\\n internal _transferReceivedItem = _transfer;\\n\\n // Utilize assembly to override the virtual function pointer.\\n assembly {\\n // Cast ReceivedItem type to ConsiderationItem type.\\n _transferConsiderationItem := _transferReceivedItem\\n }\\n }\\n\\n // Read consideration array length from memory and place on stack.\\n uint256 totalConsiderationItems = orderParameters\\n .consideration\\n .length;\\n\\n // Iterate over each consideration item on the order.\\n // Skip overflow check as for loop is indexed starting at zero.\\n for (uint256 i = 0; i < totalConsiderationItems; ++i) {\\n // Retrieve the consideration item.\\n ConsiderationItem memory considerationItem = (\\n orderParameters.consideration[i]\\n );\\n\\n // Apply fraction & derive considerationItem amount to transfer.\\n uint256 amount = _applyFraction(\\n considerationItem.startAmount,\\n considerationItem.endAmount,\\n numerator,\\n denominator,\\n startTime,\\n endTime,\\n true\\n );\\n\\n // Use assembly to set overloaded considerationItem arguments.\\n assembly {\\n // Write derived fractional amount to startAmount as amount.\\n mstore(\\n add(considerationItem, ReceivedItem_amount_offset),\\n amount\\n )\\n\\n // Write original recipient to endAmount as recipient.\\n mstore(\\n add(considerationItem, ReceivedItem_recipient_offset),\\n mload(\\n add(\\n considerationItem,\\n ConsiderationItem_recipient_offset\\n )\\n )\\n )\\n }\\n\\n // Reduce available value if offer spent ETH or a native token.\\n if (considerationItem.itemType == ItemType.NATIVE) {\\n // Ensure that sufficient native tokens are still available.\\n if (amount > etherRemaining) {\\n revert InsufficientEtherSupplied();\\n }\\n\\n // Skip underflow check as a comparison has just been made.\\n etherRemaining -= amount;\\n }\\n\\n // Transfer item from caller to recipient specified by the item.\\n _transferConsiderationItem(\\n considerationItem,\\n msg.sender,\\n fulfillerConduitKey,\\n accumulator\\n );\\n }\\n }\\n\\n // Trigger any remaining accumulated transfers via call to the conduit.\\n _triggerIfArmed(accumulator);\\n\\n // If any ether remains after fulfillments...\\n if (etherRemaining != 0) {\\n // return it to the caller.\\n _transferEth(payable(msg.sender), etherRemaining);\\n }\\n }\\n\\n /**\\n * @dev Internal function to emit an OrderFulfilled event. OfferItems are\\n * translated into SpentItems and ConsiderationItems are translated\\n * into ReceivedItems.\\n *\\n * @param orderHash The order hash.\\n * @param offerer The offerer for the order.\\n * @param zone The zone for the order.\\n * @param fulfiller The fulfiller of the order, or the null address if\\n * the order was fulfilled via order matching.\\n * @param offer The offer items for the order.\\n * @param consideration The consideration items for the order.\\n */\\n function _emitOrderFulfilledEvent(\\n bytes32 orderHash,\\n address offerer,\\n address zone,\\n address fulfiller,\\n OfferItem[] memory offer,\\n ConsiderationItem[] memory consideration\\n ) internal {\\n // Cast already-modified offer memory region as spent items.\\n SpentItem[] memory spentItems;\\n assembly {\\n spentItems := offer\\n }\\n\\n // Cast already-modified consideration memory region as received items.\\n ReceivedItem[] memory receivedItems;\\n assembly {\\n receivedItems := consideration\\n }\\n\\n // Emit an event signifying that the order has been fulfilled.\\n emit OrderFulfilled(\\n orderHash,\\n offerer,\\n zone,\\n fulfiller,\\n spentItems,\\n receivedItems\\n );\\n }\\n\\n /**\\n * @dev Internal pure function to convert an order to an advanced order with\\n * numerator and denominator of 1 and empty extraData.\\n *\\n * @param order The order to convert.\\n *\\n * @return advancedOrder The new advanced order.\\n */\\n function _convertOrderToAdvanced(Order calldata order)\\n internal\\n pure\\n returns (AdvancedOrder memory advancedOrder)\\n {\\n // Convert to partial order (1/1 or full fill) and return new value.\\n advancedOrder = AdvancedOrder(\\n order.parameters,\\n 1,\\n 1,\\n order.signature,\\n \\\"\\\"\\n );\\n }\\n\\n /**\\n * @dev Internal pure function to convert an array of orders to an array of\\n * advanced orders with numerator and denominator of 1.\\n *\\n * @param orders The orders to convert.\\n *\\n * @return advancedOrders The new array of partial orders.\\n */\\n function _convertOrdersToAdvanced(Order[] calldata orders)\\n internal\\n pure\\n returns (AdvancedOrder[] memory advancedOrders)\\n {\\n // Read the number of orders from calldata and place on the stack.\\n uint256 totalOrders = orders.length;\\n\\n // Allocate new empty array for each partial order in memory.\\n advancedOrders = new AdvancedOrder[](totalOrders);\\n\\n // Skip overflow check as the index for the loop starts at zero.\\n unchecked {\\n // Iterate over the given orders.\\n for (uint256 i = 0; i < totalOrders; ++i) {\\n // Convert to partial order (1/1 or full fill) and update array.\\n advancedOrders[i] = _convertOrderToAdvanced(orders[i]);\\n }\\n }\\n\\n // Return the array of advanced orders.\\n return advancedOrders;\\n }\\n}\\n\",\"keccak256\":\"0xb07a8d35c5e00b763cb169f3db89aa53d3e1920d6bbba33e1a0f8fad010d5342\",\"license\":\"MIT\"},\"contracts/lib/OrderValidator.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.13;\\n\\nimport { OrderType } from \\\"./ConsiderationEnums.sol\\\";\\n\\n// prettier-ignore\\nimport {\\n OrderParameters,\\n Order,\\n AdvancedOrder,\\n OrderComponents,\\n OrderStatus,\\n CriteriaResolver\\n} from \\\"./ConsiderationStructs.sol\\\";\\n\\nimport \\\"./ConsiderationConstants.sol\\\";\\n\\nimport { Executor } from \\\"./Executor.sol\\\";\\n\\nimport { ZoneInteraction } from \\\"./ZoneInteraction.sol\\\";\\n\\n/**\\n * @title OrderValidator\\n * @author 0age\\n * @notice OrderValidator contains functionality related to validating orders\\n * and updating their status.\\n */\\ncontract OrderValidator is Executor, ZoneInteraction {\\n // Track status of each order (validated, cancelled, and fraction filled).\\n mapping(bytes32 => OrderStatus) private _orderStatus;\\n\\n /**\\n * @dev Derive and set hashes, reference chainId, and associated domain\\n * separator during deployment.\\n *\\n * @param conduitController A contract that deploys conduits, or proxies\\n * that may optionally be used to transfer approved\\n * ERC20/721/1155 tokens.\\n */\\n constructor(address conduitController) Executor(conduitController) {}\\n\\n /**\\n * @dev Internal function to verify and update the status of a basic order.\\n *\\n * @param orderHash The hash of the order.\\n * @param offerer The offerer of the order.\\n * @param signature A signature from the offerer indicating that the order\\n * has been approved.\\n */\\n function _validateBasicOrderAndUpdateStatus(\\n bytes32 orderHash,\\n address offerer,\\n bytes memory signature\\n ) internal {\\n // Retrieve the order status for the given order hash.\\n OrderStatus storage orderStatus = _orderStatus[orderHash];\\n\\n // Ensure order is fillable and is not cancelled.\\n _verifyOrderStatus(\\n orderHash,\\n orderStatus,\\n true, // Only allow unused orders when fulfilling basic orders.\\n true // Signifies to revert if the order is invalid.\\n );\\n\\n // If the order is not already validated, verify the supplied signature.\\n if (!orderStatus.isValidated) {\\n _verifySignature(offerer, orderHash, signature);\\n }\\n\\n // Update order status as fully filled, packing struct values.\\n orderStatus.isValidated = true;\\n orderStatus.isCancelled = false;\\n orderStatus.numerator = 1;\\n orderStatus.denominator = 1;\\n }\\n\\n /**\\n * @dev Internal function to validate an order, determine what portion to\\n * fill, and update its status. The desired fill amount is supplied as\\n * a fraction, as is the returned amount to fill.\\n *\\n * @param advancedOrder The order to fulfill as well as the fraction to\\n * fill. Note that all offer and consideration\\n * amounts must divide with no remainder in order\\n * for a partial fill to be valid.\\n * @param criteriaResolvers An array where each element contains a reference\\n * to a specific offer or consideration, a token\\n * identifier, and a proof that the supplied token\\n * identifier is contained in the order's merkle\\n * root. Note that a criteria of zero indicates\\n * that any (transferable) token identifier is\\n * valid and that no proof needs to be supplied.\\n * @param revertOnInvalid A boolean indicating whether to revert if the\\n * order is invalid due to the time or status.\\n * @param priorOrderHashes The order hashes of each order supplied prior to\\n * the current order as part of a \\\"match\\\" variety\\n * of order fulfillment (e.g. this array will be\\n * empty for single or \\\"fulfill available\\\").\\n *\\n * @return orderHash The order hash.\\n * @return newNumerator A value indicating the portion of the order that\\n * will be filled.\\n * @return newDenominator A value indicating the total size of the order.\\n */\\n function _validateOrderAndUpdateStatus(\\n AdvancedOrder memory advancedOrder,\\n CriteriaResolver[] memory criteriaResolvers,\\n bool revertOnInvalid,\\n bytes32[] memory priorOrderHashes\\n )\\n internal\\n returns (\\n bytes32 orderHash,\\n uint256 newNumerator,\\n uint256 newDenominator\\n )\\n {\\n // Retrieve the parameters for the order.\\n OrderParameters memory orderParameters = advancedOrder.parameters;\\n\\n // Ensure current timestamp falls between order start time and end time.\\n if (\\n !_verifyTime(\\n orderParameters.startTime,\\n orderParameters.endTime,\\n revertOnInvalid\\n )\\n ) {\\n // Assuming an invalid time and no revert, return zeroed out values.\\n return (bytes32(0), 0, 0);\\n }\\n\\n // Read numerator and denominator from memory and place on the stack.\\n uint256 numerator = uint256(advancedOrder.numerator);\\n uint256 denominator = uint256(advancedOrder.denominator);\\n\\n // Ensure that the supplied numerator and denominator are valid.\\n if (numerator > denominator || numerator == 0) {\\n revert BadFraction();\\n }\\n\\n // If attempting partial fill (n < d) check order type & ensure support.\\n if (\\n numerator < denominator &&\\n _doesNotSupportPartialFills(orderParameters.orderType)\\n ) {\\n // Revert if partial fill was attempted on an unsupported order.\\n revert PartialFillsNotEnabledForOrder();\\n }\\n\\n // Retrieve current counter & use it w/ parameters to derive order hash.\\n orderHash = _assertConsiderationLengthAndGetOrderHash(orderParameters);\\n\\n // Ensure restricted orders have a valid submitter or pass a zone check.\\n _assertRestrictedAdvancedOrderValidity(\\n advancedOrder,\\n criteriaResolvers,\\n priorOrderHashes,\\n orderHash,\\n orderParameters.zoneHash,\\n orderParameters.orderType,\\n orderParameters.offerer,\\n orderParameters.zone\\n );\\n\\n // Retrieve the order status using the derived order hash.\\n OrderStatus storage orderStatus = _orderStatus[orderHash];\\n\\n // Ensure order is fillable and is not cancelled.\\n if (\\n !_verifyOrderStatus(\\n orderHash,\\n orderStatus,\\n false, // Allow partially used orders to be filled.\\n revertOnInvalid\\n )\\n ) {\\n // Assuming an invalid order status and no revert, return zero fill.\\n return (orderHash, 0, 0);\\n }\\n\\n // If the order is not already validated, verify the supplied signature.\\n if (!orderStatus.isValidated) {\\n _verifySignature(\\n orderParameters.offerer,\\n orderHash,\\n advancedOrder.signature\\n );\\n }\\n\\n // Read filled amount as numerator and denominator and put on the stack.\\n uint256 filledNumerator = orderStatus.numerator;\\n uint256 filledDenominator = orderStatus.denominator;\\n\\n // If order (orderStatus) currently has a non-zero denominator it is\\n // partially filled.\\n if (filledDenominator != 0) {\\n // If denominator of 1 supplied, fill all remaining amount on order.\\n if (denominator == 1) {\\n // Scale numerator & denominator to match current denominator.\\n numerator = filledDenominator;\\n denominator = filledDenominator;\\n }\\n // Otherwise, if supplied denominator differs from current one...\\n else if (filledDenominator != denominator) {\\n // scale current numerator by the supplied denominator, then...\\n filledNumerator *= denominator;\\n\\n // the supplied numerator & denominator by current denominator.\\n numerator *= filledDenominator;\\n denominator *= filledDenominator;\\n }\\n\\n // Once adjusted, if current+supplied numerator exceeds denominator:\\n if (filledNumerator + numerator > denominator) {\\n // Skip underflow check: denominator >= orderStatus.numerator\\n unchecked {\\n // Reduce current numerator so it + supplied = denominator.\\n numerator = denominator - filledNumerator;\\n }\\n }\\n\\n // Increment the filled numerator by the new numerator.\\n filledNumerator += numerator;\\n\\n // Use assembly to ensure fractional amounts are below max uint120.\\n assembly {\\n // Check filledNumerator and denominator for uint120 overflow.\\n if or(\\n gt(filledNumerator, MaxUint120),\\n gt(denominator, MaxUint120)\\n ) {\\n // Derive greatest common divisor using euclidean algorithm.\\n function gcd(_a, _b) -> out {\\n for {\\n\\n } _b {\\n\\n } {\\n let _c := _b\\n _b := mod(_a, _c)\\n _a := _c\\n }\\n out := _a\\n }\\n let scaleDown := gcd(\\n numerator,\\n gcd(filledNumerator, denominator)\\n )\\n\\n // Ensure that the divisor is at least one.\\n let safeScaleDown := add(scaleDown, iszero(scaleDown))\\n\\n // Scale all fractional values down by gcd.\\n numerator := div(numerator, safeScaleDown)\\n filledNumerator := div(filledNumerator, safeScaleDown)\\n denominator := div(denominator, safeScaleDown)\\n\\n // Perform the overflow check a second time.\\n if or(\\n gt(filledNumerator, MaxUint120),\\n gt(denominator, MaxUint120)\\n ) {\\n // Store the Panic error signature.\\n mstore(0, Panic_error_signature)\\n\\n // Set arithmetic (0x11) panic code as initial argument.\\n mstore(Panic_error_offset, Panic_arithmetic)\\n\\n // Return, supplying Panic signature & arithmetic code.\\n revert(0, Panic_error_length)\\n }\\n }\\n }\\n // Skip overflow check: checked above unless numerator is reduced.\\n unchecked {\\n // Update order status and fill amount, packing struct values.\\n orderStatus.isValidated = true;\\n orderStatus.isCancelled = false;\\n orderStatus.numerator = uint120(filledNumerator);\\n orderStatus.denominator = uint120(denominator);\\n }\\n } else {\\n // Update order status and fill amount, packing struct values.\\n orderStatus.isValidated = true;\\n orderStatus.isCancelled = false;\\n orderStatus.numerator = uint120(numerator);\\n orderStatus.denominator = uint120(denominator);\\n }\\n\\n // Return order hash, a modified numerator, and a modified denominator.\\n return (orderHash, numerator, denominator);\\n }\\n\\n /**\\n * @dev Internal function to cancel an arbitrary number of orders. Note that\\n * only the offerer or the zone of a given order may cancel it. Callers\\n * should ensure that the intended order was cancelled by calling\\n * `getOrderStatus` and confirming that `isCancelled` returns `true`.\\n *\\n * @param orders The orders to cancel.\\n *\\n * @return cancelled A boolean indicating whether the supplied orders were\\n * successfully cancelled.\\n */\\n function _cancel(OrderComponents[] calldata orders)\\n internal\\n returns (bool cancelled)\\n {\\n // Ensure that the reentrancy guard is not currently set.\\n _assertNonReentrant();\\n\\n // Declare variables outside of the loop.\\n OrderStatus storage orderStatus;\\n address offerer;\\n address zone;\\n\\n // Skip overflow check as for loop is indexed starting at zero.\\n unchecked {\\n // Read length of the orders array from memory and place on stack.\\n uint256 totalOrders = orders.length;\\n\\n // Iterate over each order.\\n for (uint256 i = 0; i < totalOrders; ) {\\n // Retrieve the order.\\n OrderComponents calldata order = orders[i];\\n\\n offerer = order.offerer;\\n zone = order.zone;\\n\\n // Ensure caller is either offerer or zone of the order.\\n if (msg.sender != offerer && msg.sender != zone) {\\n revert InvalidCanceller();\\n }\\n\\n // Derive order hash using the order parameters and the counter.\\n bytes32 orderHash = _deriveOrderHash(\\n OrderParameters(\\n offerer,\\n zone,\\n order.offer,\\n order.consideration,\\n order.orderType,\\n order.startTime,\\n order.endTime,\\n order.zoneHash,\\n order.salt,\\n order.conduitKey,\\n order.consideration.length\\n ),\\n order.counter\\n );\\n\\n // Retrieve the order status using the derived order hash.\\n orderStatus = _orderStatus[orderHash];\\n\\n // Update the order status as not valid and cancelled.\\n orderStatus.isValidated = false;\\n orderStatus.isCancelled = true;\\n\\n // Emit an event signifying that the order has been cancelled.\\n emit OrderCancelled(orderHash, offerer, zone);\\n\\n // Increment counter inside body of loop for gas efficiency.\\n ++i;\\n }\\n }\\n\\n // Return a boolean indicating that orders were successfully cancelled.\\n cancelled = true;\\n }\\n\\n /**\\n * @dev Internal function to validate an arbitrary number of orders, thereby\\n * registering their signatures as valid and allowing the fulfiller to\\n * skip signature verification on fulfillment. Note that validated\\n * orders may still be unfulfillable due to invalid item amounts or\\n * other factors; callers should determine whether validated orders are\\n * fulfillable by simulating the fulfillment call prior to execution.\\n * Also note that anyone can validate a signed order, but only the\\n * offerer can validate an order without supplying a signature.\\n *\\n * @param orders The orders to validate.\\n *\\n * @return validated A boolean indicating whether the supplied orders were\\n * successfully validated.\\n */\\n function _validate(Order[] calldata orders)\\n internal\\n returns (bool validated)\\n {\\n // Ensure that the reentrancy guard is not currently set.\\n _assertNonReentrant();\\n\\n // Declare variables outside of the loop.\\n OrderStatus storage orderStatus;\\n bytes32 orderHash;\\n address offerer;\\n\\n // Skip overflow check as for loop is indexed starting at zero.\\n unchecked {\\n // Read length of the orders array from memory and place on stack.\\n uint256 totalOrders = orders.length;\\n\\n // Iterate over each order.\\n for (uint256 i = 0; i < totalOrders; ) {\\n // Retrieve the order.\\n Order calldata order = orders[i];\\n\\n // Retrieve the order parameters.\\n OrderParameters calldata orderParameters = order.parameters;\\n\\n // Move offerer from memory to the stack.\\n offerer = orderParameters.offerer;\\n\\n // Get current counter & use it w/ params to derive order hash.\\n orderHash = _assertConsiderationLengthAndGetOrderHash(\\n orderParameters\\n );\\n\\n // Retrieve the order status using the derived order hash.\\n orderStatus = _orderStatus[orderHash];\\n\\n // Ensure order is fillable and retrieve the filled amount.\\n _verifyOrderStatus(\\n orderHash,\\n orderStatus,\\n false, // Signifies that partially filled orders are valid.\\n true // Signifies to revert if the order is invalid.\\n );\\n\\n // If the order has not already been validated...\\n if (!orderStatus.isValidated) {\\n // Verify the supplied signature.\\n _verifySignature(offerer, orderHash, order.signature);\\n\\n // Update order status to mark the order as valid.\\n orderStatus.isValidated = true;\\n\\n // Emit an event signifying the order has been validated.\\n emit OrderValidated(\\n orderHash,\\n offerer,\\n orderParameters.zone\\n );\\n }\\n\\n // Increment counter inside body of the loop for gas efficiency.\\n ++i;\\n }\\n }\\n\\n // Return a boolean indicating that orders were successfully validated.\\n validated = true;\\n }\\n\\n /**\\n * @dev Internal view function to retrieve the status of a given order by\\n * hash, including whether the order has been cancelled or validated\\n * and the fraction of the order that has been filled.\\n *\\n * @param orderHash The order hash in question.\\n *\\n * @return isValidated A boolean indicating whether the order in question\\n * has been validated (i.e. previously approved or\\n * partially filled).\\n * @return isCancelled A boolean indicating whether the order in question\\n * has been cancelled.\\n * @return totalFilled The total portion of the order that has been filled\\n * (i.e. the \\\"numerator\\\").\\n * @return totalSize The total size of the order that is either filled or\\n * unfilled (i.e. the \\\"denominator\\\").\\n */\\n function _getOrderStatus(bytes32 orderHash)\\n internal\\n view\\n returns (\\n bool isValidated,\\n bool isCancelled,\\n uint256 totalFilled,\\n uint256 totalSize\\n )\\n {\\n // Retrieve the order status using the order hash.\\n OrderStatus storage orderStatus = _orderStatus[orderHash];\\n\\n // Return the fields on the order status.\\n return (\\n orderStatus.isValidated,\\n orderStatus.isCancelled,\\n orderStatus.numerator,\\n orderStatus.denominator\\n );\\n }\\n\\n /**\\n * @dev Internal pure function to check whether a given order type indicates\\n * that partial fills are not supported (e.g. only \\\"full fills\\\" are\\n * allowed for the order in question).\\n *\\n * @param orderType The order type in question.\\n *\\n * @return isFullOrder A boolean indicating whether the order type only\\n * supports full fills.\\n */\\n function _doesNotSupportPartialFills(OrderType orderType)\\n internal\\n pure\\n returns (bool isFullOrder)\\n {\\n // The \\\"full\\\" order types are even, while \\\"partial\\\" order types are odd.\\n // Bitwise and by 1 is equivalent to modulo by 2, but 2 gas cheaper.\\n assembly {\\n // Equivalent to `uint256(orderType) & 1 == 0`.\\n isFullOrder := iszero(and(orderType, 1))\\n }\\n }\\n}\\n\",\"keccak256\":\"0xc45e097bea3554ed472db2f7c96c6589f6e2fb2700de368671e1dc705253ac99\",\"license\":\"MIT\"},\"contracts/lib/ReentrancyGuard.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.13;\\n\\nimport { ReentrancyErrors } from \\\"../interfaces/ReentrancyErrors.sol\\\";\\n\\nimport \\\"./ConsiderationConstants.sol\\\";\\n\\n/**\\n * @title ReentrancyGuard\\n * @author 0age\\n * @notice ReentrancyGuard contains a storage variable and related functionality\\n * for protecting against reentrancy.\\n */\\ncontract ReentrancyGuard is ReentrancyErrors {\\n // Prevent reentrant calls on protected functions.\\n uint256 private _reentrancyGuard;\\n\\n /**\\n * @dev Initialize the reentrancy guard during deployment.\\n */\\n constructor() {\\n // Initialize the reentrancy guard in a cleared state.\\n _reentrancyGuard = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Internal function to ensure that the sentinel value for the\\n * reentrancy guard is not currently set and, if not, to set the\\n * sentinel value for the reentrancy guard.\\n */\\n function _setReentrancyGuard() internal {\\n // Ensure that the reentrancy guard is not already set.\\n _assertNonReentrant();\\n\\n // Set the reentrancy guard.\\n _reentrancyGuard = _ENTERED;\\n }\\n\\n /**\\n * @dev Internal function to unset the reentrancy guard sentinel value.\\n */\\n function _clearReentrancyGuard() internal {\\n // Clear the reentrancy guard.\\n _reentrancyGuard = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Internal view function to ensure that the sentinel value for the\\n reentrancy guard is not currently set.\\n */\\n function _assertNonReentrant() internal view {\\n // Ensure that the reentrancy guard is not currently set.\\n if (_reentrancyGuard != _NOT_ENTERED) {\\n revert NoReentrantCalls();\\n }\\n }\\n}\\n\",\"keccak256\":\"0xab7f4be430397b020e4dc70f86b444888bd125aa296e5ca4b951bdc01a014dcc\",\"license\":\"MIT\"},\"contracts/lib/SignatureVerification.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.13;\\n\\nimport { EIP1271Interface } from \\\"../interfaces/EIP1271Interface.sol\\\";\\n\\n// prettier-ignore\\nimport {\\n SignatureVerificationErrors\\n} from \\\"../interfaces/SignatureVerificationErrors.sol\\\";\\n\\nimport { LowLevelHelpers } from \\\"./LowLevelHelpers.sol\\\";\\n\\nimport \\\"./ConsiderationConstants.sol\\\";\\n\\n/**\\n * @title SignatureVerification\\n * @author 0age\\n * @notice SignatureVerification contains logic for verifying signatures.\\n */\\ncontract SignatureVerification is SignatureVerificationErrors, LowLevelHelpers {\\n /**\\n * @dev Internal view function to verify the signature of an order. An\\n * ERC-1271 fallback will be attempted if either the signature length\\n * is not 64 or 65 bytes or if the recovered signer does not match the\\n * supplied signer.\\n *\\n * @param signer The signer for the order.\\n * @param digest The digest to verify the signature against.\\n * @param signature A signature from the signer indicating that the order\\n * has been approved.\\n */\\n function _assertValidSignature(\\n address signer,\\n bytes32 digest,\\n bytes memory signature\\n ) internal view {\\n // Declare value for ecrecover equality or 1271 call success status.\\n bool success;\\n\\n // Utilize assembly to perform optimized signature verification check.\\n assembly {\\n // Ensure that first word of scratch space is empty.\\n mstore(0, 0)\\n\\n // Declare value for v signature parameter.\\n let v\\n\\n // Get the length of the signature.\\n let signatureLength := mload(signature)\\n\\n // Get the pointer to the value preceding the signature length.\\n // This will be used for temporary memory overrides - either the\\n // signature head for isValidSignature or the digest for ecrecover.\\n let wordBeforeSignaturePtr := sub(signature, OneWord)\\n\\n // Cache the current value behind the signature to restore it later.\\n let cachedWordBeforeSignature := mload(wordBeforeSignaturePtr)\\n\\n // Declare lenDiff + recoveredSigner scope to manage stack pressure.\\n {\\n // Take the difference between the max ECDSA signature length\\n // and the actual signature length. Overflow desired for any\\n // values > 65. If the diff is not 0 or 1, it is not a valid\\n // ECDSA signature - move on to EIP1271 check.\\n let lenDiff := sub(ECDSA_MaxLength, signatureLength)\\n\\n // Declare variable for recovered signer.\\n let recoveredSigner\\n\\n // If diff is 0 or 1, it may be an ECDSA signature.\\n // Try to recover signer.\\n if iszero(gt(lenDiff, 1)) {\\n // Read the signature `s` value.\\n let originalSignatureS := mload(\\n add(signature, ECDSA_signature_s_offset)\\n )\\n\\n // Read the first byte of the word after `s`. If the\\n // signature is 65 bytes, this will be the real `v` value.\\n // If not, it will need to be modified - doing it this way\\n // saves an extra condition.\\n v := byte(\\n 0,\\n mload(add(signature, ECDSA_signature_v_offset))\\n )\\n\\n // If lenDiff is 1, parse 64-byte signature as ECDSA.\\n if lenDiff {\\n // Extract yParity from highest bit of vs and add 27 to\\n // get v.\\n v := add(\\n shr(MaxUint8, originalSignatureS),\\n Signature_lower_v\\n )\\n\\n // Extract canonical s from vs, all but the highest bit.\\n // Temporarily overwrite the original `s` value in the\\n // signature.\\n mstore(\\n add(signature, ECDSA_signature_s_offset),\\n and(\\n originalSignatureS,\\n EIP2098_allButHighestBitMask\\n )\\n )\\n }\\n // Temporarily overwrite the signature length with `v` to\\n // conform to the expected input for ecrecover.\\n mstore(signature, v)\\n\\n // Temporarily overwrite the word before the length with\\n // `digest` to conform to the expected input for ecrecover.\\n mstore(wordBeforeSignaturePtr, digest)\\n\\n // Attempt to recover the signer for the given signature. Do\\n // not check the call status as ecrecover will return a null\\n // address if the signature is invalid.\\n pop(\\n staticcall(\\n gas(),\\n Ecrecover_precompile, // Call ecrecover precompile.\\n wordBeforeSignaturePtr, // Use data memory location.\\n Ecrecover_args_size, // Size of digest, v, r, and s.\\n 0, // Write result to scratch space.\\n OneWord // Provide size of returned result.\\n )\\n )\\n\\n // Restore cached word before signature.\\n mstore(wordBeforeSignaturePtr, cachedWordBeforeSignature)\\n\\n // Restore cached signature length.\\n mstore(signature, signatureLength)\\n\\n // Restore cached signature `s` value.\\n mstore(\\n add(signature, ECDSA_signature_s_offset),\\n originalSignatureS\\n )\\n\\n // Read the recovered signer from the buffer given as return\\n // space for ecrecover.\\n recoveredSigner := mload(0)\\n }\\n\\n // Set success to true if the signature provided was a valid\\n // ECDSA signature and the signer is not the null address. Use\\n // gt instead of direct as success is used outside of assembly.\\n success := and(eq(signer, recoveredSigner), gt(signer, 0))\\n }\\n\\n // If the signature was not verified with ecrecover, try EIP1271.\\n if iszero(success) {\\n // Temporarily overwrite the word before the signature length\\n // and use it as the head of the signature input to\\n // `isValidSignature`, which has a value of 64.\\n mstore(\\n wordBeforeSignaturePtr,\\n EIP1271_isValidSignature_signature_head_offset\\n )\\n\\n // Get pointer to use for the selector of `isValidSignature`.\\n let selectorPtr := sub(\\n signature,\\n EIP1271_isValidSignature_selector_negativeOffset\\n )\\n\\n // Cache the value currently stored at the selector pointer.\\n let cachedWordOverwrittenBySelector := mload(selectorPtr)\\n\\n // Get pointer to use for `digest` input to `isValidSignature`.\\n let digestPtr := sub(\\n signature,\\n EIP1271_isValidSignature_digest_negativeOffset\\n )\\n\\n // Cache the value currently stored at the digest pointer.\\n let cachedWordOverwrittenByDigest := mload(digestPtr)\\n\\n // Write the selector first, since it overlaps the digest.\\n mstore(selectorPtr, EIP1271_isValidSignature_selector)\\n\\n // Next, write the digest.\\n mstore(digestPtr, digest)\\n\\n // Call signer with `isValidSignature` to validate signature.\\n success := staticcall(\\n gas(),\\n signer,\\n selectorPtr,\\n add(\\n signatureLength,\\n EIP1271_isValidSignature_calldata_baseLength\\n ),\\n 0,\\n OneWord\\n )\\n\\n // Determine if the signature is valid on successful calls.\\n if success {\\n // If first word of scratch space does not contain EIP-1271\\n // signature selector, revert.\\n if iszero(eq(mload(0), EIP1271_isValidSignature_selector)) {\\n // Revert with bad 1271 signature if signer has code.\\n if extcodesize(signer) {\\n // Bad contract signature.\\n mstore(0, BadContractSignature_error_signature)\\n revert(0, BadContractSignature_error_length)\\n }\\n\\n // Check if signature length was invalid.\\n if gt(sub(ECDSA_MaxLength, signatureLength), 1) {\\n // Revert with generic invalid signature error.\\n mstore(0, InvalidSignature_error_signature)\\n revert(0, InvalidSignature_error_length)\\n }\\n\\n // Check if v was invalid.\\n if iszero(\\n byte(v, ECDSA_twentySeventhAndTwentyEighthBytesSet)\\n ) {\\n // Revert with invalid v value.\\n mstore(0, BadSignatureV_error_signature)\\n mstore(BadSignatureV_error_offset, v)\\n revert(0, BadSignatureV_error_length)\\n }\\n\\n // Revert with generic invalid signer error message.\\n mstore(0, InvalidSigner_error_signature)\\n revert(0, InvalidSigner_error_length)\\n }\\n }\\n\\n // Restore the cached values overwritten by selector, digest and\\n // signature head.\\n mstore(wordBeforeSignaturePtr, cachedWordBeforeSignature)\\n mstore(selectorPtr, cachedWordOverwrittenBySelector)\\n mstore(digestPtr, cachedWordOverwrittenByDigest)\\n }\\n }\\n\\n // If the call failed...\\n if (!success) {\\n // Revert and pass reason along if one was returned.\\n _revertWithReasonIfOneIsReturned();\\n\\n // Otherwise, revert with error indicating bad contract signature.\\n assembly {\\n mstore(0, BadContractSignature_error_signature)\\n revert(0, BadContractSignature_error_length)\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x41981411f81c07e920279f45f333cc18553777336121c2590525228ddaf09afa\",\"license\":\"MIT\"},\"contracts/lib/TokenTransferrer.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.7;\\n\\nimport \\\"./TokenTransferrerConstants.sol\\\";\\n\\n// prettier-ignore\\nimport {\\n TokenTransferrerErrors\\n} from \\\"../interfaces/TokenTransferrerErrors.sol\\\";\\n\\nimport { ConduitBatch1155Transfer } from \\\"../conduit/lib/ConduitStructs.sol\\\";\\n\\n/**\\n * @title TokenTransferrer\\n * @author 0age\\n * @custom:coauthor d1ll0n\\n * @custom:coauthor transmissions11\\n * @notice TokenTransferrer is a library for performing optimized ERC20, ERC721,\\n * ERC1155, and batch ERC1155 transfers, used by both Seaport as well as\\n * by conduits deployed by the ConduitController. Use great caution when\\n * considering these functions for use in other codebases, as there are\\n * significant side effects and edge cases that need to be thoroughly\\n * understood and carefully addressed.\\n */\\ncontract TokenTransferrer is TokenTransferrerErrors {\\n /**\\n * @dev Internal function to transfer ERC20 tokens from a given originator\\n * to a given recipient. Sufficient approvals must be set on the\\n * contract performing the transfer.\\n *\\n * @param token The ERC20 token to transfer.\\n * @param from The originator of the transfer.\\n * @param to The recipient of the transfer.\\n * @param amount The amount to transfer.\\n */\\n function _performERC20Transfer(\\n address token,\\n address from,\\n address to,\\n uint256 amount\\n ) internal {\\n // Utilize assembly to perform an optimized ERC20 token transfer.\\n assembly {\\n // The free memory pointer memory slot will be used when populating\\n // call data for the transfer; read the value and restore it later.\\n let memPointer := mload(FreeMemoryPointerSlot)\\n\\n // Write call data into memory, starting with function selector.\\n mstore(ERC20_transferFrom_sig_ptr, ERC20_transferFrom_signature)\\n mstore(ERC20_transferFrom_from_ptr, from)\\n mstore(ERC20_transferFrom_to_ptr, to)\\n mstore(ERC20_transferFrom_amount_ptr, amount)\\n\\n // Make call & copy up to 32 bytes of return data to scratch space.\\n // Scratch space does not need to be cleared ahead of time, as the\\n // subsequent check will ensure that either at least a full word of\\n // return data is received (in which case it will be overwritten) or\\n // that no data is received (in which case scratch space will be\\n // ignored) on a successful call to the given token.\\n let callStatus := call(\\n gas(),\\n token,\\n 0,\\n ERC20_transferFrom_sig_ptr,\\n ERC20_transferFrom_length,\\n 0,\\n OneWord\\n )\\n\\n // Determine whether transfer was successful using status & result.\\n let success := and(\\n // Set success to whether the call reverted, if not check it\\n // either returned exactly 1 (can't just be non-zero data), or\\n // had no return data.\\n or(\\n and(eq(mload(0), 1), gt(returndatasize(), 31)),\\n iszero(returndatasize())\\n ),\\n callStatus\\n )\\n\\n // Handle cases where either the transfer failed or no data was\\n // returned. Group these, as most transfers will succeed with data.\\n // Equivalent to `or(iszero(success), iszero(returndatasize()))`\\n // but after it's inverted for JUMPI this expression is cheaper.\\n if iszero(and(success, iszero(iszero(returndatasize())))) {\\n // If the token has no code or the transfer failed: Equivalent\\n // to `or(iszero(success), iszero(extcodesize(token)))` but\\n // after it's inverted for JUMPI this expression is cheaper.\\n if iszero(and(iszero(iszero(extcodesize(token))), success)) {\\n // If the transfer failed:\\n if iszero(success) {\\n // If it was due to a revert:\\n if iszero(callStatus) {\\n // If it returned a message, bubble it up as long as\\n // sufficient gas remains to do so:\\n if returndatasize() {\\n // Ensure that sufficient gas is available to\\n // copy returndata while expanding memory where\\n // necessary. Start by computing the word size\\n // of returndata and allocated memory. Round up\\n // to the nearest full word.\\n let returnDataWords := div(\\n add(returndatasize(), AlmostOneWord),\\n OneWord\\n )\\n\\n // Note: use the free memory pointer in place of\\n // msize() to work around a Yul warning that\\n // prevents accessing msize directly when the IR\\n // pipeline is activated.\\n let msizeWords := div(memPointer, OneWord)\\n\\n // Next, compute the cost of the returndatacopy.\\n let cost := mul(CostPerWord, returnDataWords)\\n\\n // Then, compute cost of new memory allocation.\\n if gt(returnDataWords, msizeWords) {\\n cost := add(\\n cost,\\n add(\\n mul(\\n sub(\\n returnDataWords,\\n msizeWords\\n ),\\n CostPerWord\\n ),\\n div(\\n sub(\\n mul(\\n returnDataWords,\\n returnDataWords\\n ),\\n mul(msizeWords, msizeWords)\\n ),\\n MemoryExpansionCoefficient\\n )\\n )\\n )\\n }\\n\\n // Finally, add a small constant and compare to\\n // gas remaining; bubble up the revert data if\\n // enough gas is still available.\\n if lt(add(cost, ExtraGasBuffer), gas()) {\\n // Copy returndata to memory; overwrite\\n // existing memory.\\n returndatacopy(0, 0, returndatasize())\\n\\n // Revert, specifying memory region with\\n // copied returndata.\\n revert(0, returndatasize())\\n }\\n }\\n\\n // Otherwise revert with a generic error message.\\n mstore(\\n TokenTransferGenericFailure_error_sig_ptr,\\n TokenTransferGenericFailure_error_signature\\n )\\n mstore(\\n TokenTransferGenericFailure_error_token_ptr,\\n token\\n )\\n mstore(\\n TokenTransferGenericFailure_error_from_ptr,\\n from\\n )\\n mstore(TokenTransferGenericFailure_error_to_ptr, to)\\n mstore(TokenTransferGenericFailure_error_id_ptr, 0)\\n mstore(\\n TokenTransferGenericFailure_error_amount_ptr,\\n amount\\n )\\n revert(\\n TokenTransferGenericFailure_error_sig_ptr,\\n TokenTransferGenericFailure_error_length\\n )\\n }\\n\\n // Otherwise revert with a message about the token\\n // returning false or non-compliant return values.\\n mstore(\\n BadReturnValueFromERC20OnTransfer_error_sig_ptr,\\n BadReturnValueFromERC20OnTransfer_error_signature\\n )\\n mstore(\\n BadReturnValueFromERC20OnTransfer_error_token_ptr,\\n token\\n )\\n mstore(\\n BadReturnValueFromERC20OnTransfer_error_from_ptr,\\n from\\n )\\n mstore(\\n BadReturnValueFromERC20OnTransfer_error_to_ptr,\\n to\\n )\\n mstore(\\n BadReturnValueFromERC20OnTransfer_error_amount_ptr,\\n amount\\n )\\n revert(\\n BadReturnValueFromERC20OnTransfer_error_sig_ptr,\\n BadReturnValueFromERC20OnTransfer_error_length\\n )\\n }\\n\\n // Otherwise, revert with error about token not having code:\\n mstore(NoContract_error_sig_ptr, NoContract_error_signature)\\n mstore(NoContract_error_token_ptr, token)\\n revert(NoContract_error_sig_ptr, NoContract_error_length)\\n }\\n\\n // Otherwise, the token just returned no data despite the call\\n // having succeeded; no need to optimize for this as it's not\\n // technically ERC20 compliant.\\n }\\n\\n // Restore the original free memory pointer.\\n mstore(FreeMemoryPointerSlot, memPointer)\\n\\n // Restore the zero slot to zero.\\n mstore(ZeroSlot, 0)\\n }\\n }\\n\\n /**\\n * @dev Internal function to transfer an ERC721 token from a given\\n * originator to a given recipient. Sufficient approvals must be set on\\n * the contract performing the transfer. Note that this function does\\n * not check whether the receiver can accept the ERC721 token (i.e. it\\n * does not use `safeTransferFrom`).\\n *\\n * @param token The ERC721 token to transfer.\\n * @param from The originator of the transfer.\\n * @param to The recipient of the transfer.\\n * @param identifier The tokenId to transfer.\\n */\\n function _performERC721Transfer(\\n address token,\\n address from,\\n address to,\\n uint256 identifier\\n ) internal {\\n // Utilize assembly to perform an optimized ERC721 token transfer.\\n assembly {\\n // If the token has no code, revert.\\n if iszero(extcodesize(token)) {\\n mstore(NoContract_error_sig_ptr, NoContract_error_signature)\\n mstore(NoContract_error_token_ptr, token)\\n revert(NoContract_error_sig_ptr, NoContract_error_length)\\n }\\n\\n // The free memory pointer memory slot will be used when populating\\n // call data for the transfer; read the value and restore it later.\\n let memPointer := mload(FreeMemoryPointerSlot)\\n\\n // Write call data to memory starting with function selector.\\n mstore(ERC721_transferFrom_sig_ptr, ERC721_transferFrom_signature)\\n mstore(ERC721_transferFrom_from_ptr, from)\\n mstore(ERC721_transferFrom_to_ptr, to)\\n mstore(ERC721_transferFrom_id_ptr, identifier)\\n\\n // Perform the call, ignoring return data.\\n let success := call(\\n gas(),\\n token,\\n 0,\\n ERC721_transferFrom_sig_ptr,\\n ERC721_transferFrom_length,\\n 0,\\n 0\\n )\\n\\n // If the transfer reverted:\\n if iszero(success) {\\n // If it returned a message, bubble it up as long as sufficient\\n // gas remains to do so:\\n if returndatasize() {\\n // Ensure that sufficient gas is available to copy\\n // returndata while expanding memory where necessary. Start\\n // by computing word size of returndata & allocated memory.\\n // Round up to the nearest full word.\\n let returnDataWords := div(\\n add(returndatasize(), AlmostOneWord),\\n OneWord\\n )\\n\\n // Note: use the free memory pointer in place of msize() to\\n // work around a Yul warning that prevents accessing msize\\n // directly when the IR pipeline is activated.\\n let msizeWords := div(memPointer, OneWord)\\n\\n // Next, compute the cost of the returndatacopy.\\n let cost := mul(CostPerWord, returnDataWords)\\n\\n // Then, compute cost of new memory allocation.\\n if gt(returnDataWords, msizeWords) {\\n cost := add(\\n cost,\\n add(\\n mul(\\n sub(returnDataWords, msizeWords),\\n CostPerWord\\n ),\\n div(\\n sub(\\n mul(returnDataWords, returnDataWords),\\n mul(msizeWords, msizeWords)\\n ),\\n MemoryExpansionCoefficient\\n )\\n )\\n )\\n }\\n\\n // Finally, add a small constant and compare to gas\\n // remaining; bubble up the revert data if enough gas is\\n // still available.\\n if lt(add(cost, ExtraGasBuffer), gas()) {\\n // Copy returndata to memory; overwrite existing memory.\\n returndatacopy(0, 0, returndatasize())\\n\\n // Revert, giving memory region with copied returndata.\\n revert(0, returndatasize())\\n }\\n }\\n\\n // Otherwise revert with a generic error message.\\n mstore(\\n TokenTransferGenericFailure_error_sig_ptr,\\n TokenTransferGenericFailure_error_signature\\n )\\n mstore(TokenTransferGenericFailure_error_token_ptr, token)\\n mstore(TokenTransferGenericFailure_error_from_ptr, from)\\n mstore(TokenTransferGenericFailure_error_to_ptr, to)\\n mstore(TokenTransferGenericFailure_error_id_ptr, identifier)\\n mstore(TokenTransferGenericFailure_error_amount_ptr, 1)\\n revert(\\n TokenTransferGenericFailure_error_sig_ptr,\\n TokenTransferGenericFailure_error_length\\n )\\n }\\n\\n // Restore the original free memory pointer.\\n mstore(FreeMemoryPointerSlot, memPointer)\\n\\n // Restore the zero slot to zero.\\n mstore(ZeroSlot, 0)\\n }\\n }\\n\\n /**\\n * @dev Internal function to transfer ERC1155 tokens from a given\\n * originator to a given recipient. Sufficient approvals must be set on\\n * the contract performing the transfer and contract recipients must\\n * implement the ERC1155TokenReceiver interface to indicate that they\\n * are willing to accept the transfer.\\n *\\n * @param token The ERC1155 token to transfer.\\n * @param from The originator of the transfer.\\n * @param to The recipient of the transfer.\\n * @param identifier The id to transfer.\\n * @param amount The amount to transfer.\\n */\\n function _performERC1155Transfer(\\n address token,\\n address from,\\n address to,\\n uint256 identifier,\\n uint256 amount\\n ) internal {\\n // Utilize assembly to perform an optimized ERC1155 token transfer.\\n assembly {\\n // If the token has no code, revert.\\n if iszero(extcodesize(token)) {\\n mstore(NoContract_error_sig_ptr, NoContract_error_signature)\\n mstore(NoContract_error_token_ptr, token)\\n revert(NoContract_error_sig_ptr, NoContract_error_length)\\n }\\n\\n // The following memory slots will be used when populating call data\\n // for the transfer; read the values and restore them later.\\n let memPointer := mload(FreeMemoryPointerSlot)\\n let slot0x80 := mload(Slot0x80)\\n let slot0xA0 := mload(Slot0xA0)\\n let slot0xC0 := mload(Slot0xC0)\\n\\n // Write call data into memory, beginning with function selector.\\n mstore(\\n ERC1155_safeTransferFrom_sig_ptr,\\n ERC1155_safeTransferFrom_signature\\n )\\n mstore(ERC1155_safeTransferFrom_from_ptr, from)\\n mstore(ERC1155_safeTransferFrom_to_ptr, to)\\n mstore(ERC1155_safeTransferFrom_id_ptr, identifier)\\n mstore(ERC1155_safeTransferFrom_amount_ptr, amount)\\n mstore(\\n ERC1155_safeTransferFrom_data_offset_ptr,\\n ERC1155_safeTransferFrom_data_length_offset\\n )\\n mstore(ERC1155_safeTransferFrom_data_length_ptr, 0)\\n\\n // Perform the call, ignoring return data.\\n let success := call(\\n gas(),\\n token,\\n 0,\\n ERC1155_safeTransferFrom_sig_ptr,\\n ERC1155_safeTransferFrom_length,\\n 0,\\n 0\\n )\\n\\n // If the transfer reverted:\\n if iszero(success) {\\n // If it returned a message, bubble it up as long as sufficient\\n // gas remains to do so:\\n if returndatasize() {\\n // Ensure that sufficient gas is available to copy\\n // returndata while expanding memory where necessary. Start\\n // by computing word size of returndata & allocated memory.\\n // Round up to the nearest full word.\\n let returnDataWords := div(\\n add(returndatasize(), AlmostOneWord),\\n OneWord\\n )\\n\\n // Note: use the free memory pointer in place of msize() to\\n // work around a Yul warning that prevents accessing msize\\n // directly when the IR pipeline is activated.\\n let msizeWords := div(memPointer, OneWord)\\n\\n // Next, compute the cost of the returndatacopy.\\n let cost := mul(CostPerWord, returnDataWords)\\n\\n // Then, compute cost of new memory allocation.\\n if gt(returnDataWords, msizeWords) {\\n cost := add(\\n cost,\\n add(\\n mul(\\n sub(returnDataWords, msizeWords),\\n CostPerWord\\n ),\\n div(\\n sub(\\n mul(returnDataWords, returnDataWords),\\n mul(msizeWords, msizeWords)\\n ),\\n MemoryExpansionCoefficient\\n )\\n )\\n )\\n }\\n\\n // Finally, add a small constant and compare to gas\\n // remaining; bubble up the revert data if enough gas is\\n // still available.\\n if lt(add(cost, ExtraGasBuffer), gas()) {\\n // Copy returndata to memory; overwrite existing memory.\\n returndatacopy(0, 0, returndatasize())\\n\\n // Revert, giving memory region with copied returndata.\\n revert(0, returndatasize())\\n }\\n }\\n\\n // Otherwise revert with a generic error message.\\n mstore(\\n TokenTransferGenericFailure_error_sig_ptr,\\n TokenTransferGenericFailure_error_signature\\n )\\n mstore(TokenTransferGenericFailure_error_token_ptr, token)\\n mstore(TokenTransferGenericFailure_error_from_ptr, from)\\n mstore(TokenTransferGenericFailure_error_to_ptr, to)\\n mstore(TokenTransferGenericFailure_error_id_ptr, identifier)\\n mstore(TokenTransferGenericFailure_error_amount_ptr, amount)\\n revert(\\n TokenTransferGenericFailure_error_sig_ptr,\\n TokenTransferGenericFailure_error_length\\n )\\n }\\n\\n mstore(Slot0x80, slot0x80) // Restore slot 0x80.\\n mstore(Slot0xA0, slot0xA0) // Restore slot 0xA0.\\n mstore(Slot0xC0, slot0xC0) // Restore slot 0xC0.\\n\\n // Restore the original free memory pointer.\\n mstore(FreeMemoryPointerSlot, memPointer)\\n\\n // Restore the zero slot to zero.\\n mstore(ZeroSlot, 0)\\n }\\n }\\n\\n /**\\n * @dev Internal function to transfer ERC1155 tokens from a given\\n * originator to a given recipient. Sufficient approvals must be set on\\n * the contract performing the transfer and contract recipients must\\n * implement the ERC1155TokenReceiver interface to indicate that they\\n * are willing to accept the transfer. NOTE: this function is not\\n * memory-safe; it will overwrite existing memory, restore the free\\n * memory pointer to the default value, and overwrite the zero slot.\\n * This function should only be called once memory is no longer\\n * required and when uninitialized arrays are not utilized, and memory\\n * should be considered fully corrupted (aside from the existence of a\\n * default-value free memory pointer) after calling this function.\\n *\\n * @param batchTransfers The group of 1155 batch transfers to perform.\\n */\\n function _performERC1155BatchTransfers(\\n ConduitBatch1155Transfer[] calldata batchTransfers\\n ) internal {\\n // Utilize assembly to perform optimized batch 1155 transfers.\\n assembly {\\n let len := batchTransfers.length\\n // Pointer to first head in the array, which is offset to the struct\\n // at each index. This gets incremented after each loop to avoid\\n // multiplying by 32 to get the offset for each element.\\n let nextElementHeadPtr := batchTransfers.offset\\n\\n // Pointer to beginning of the head of the array. This is the\\n // reference position each offset references. It's held static to\\n // let each loop calculate the data position for an element.\\n let arrayHeadPtr := nextElementHeadPtr\\n\\n // Write the function selector, which will be reused for each call:\\n // safeBatchTransferFrom(address,address,uint256[],uint256[],bytes)\\n mstore(\\n ConduitBatch1155Transfer_from_offset,\\n ERC1155_safeBatchTransferFrom_signature\\n )\\n\\n // Iterate over each batch transfer.\\n for {\\n let i := 0\\n } lt(i, len) {\\n i := add(i, 1)\\n } {\\n // Read the offset to the beginning of the element and add\\n // it to pointer to the beginning of the array head to get\\n // the absolute position of the element in calldata.\\n let elementPtr := add(\\n arrayHeadPtr,\\n calldataload(nextElementHeadPtr)\\n )\\n\\n // Retrieve the token from calldata.\\n let token := calldataload(elementPtr)\\n\\n // If the token has no code, revert.\\n if iszero(extcodesize(token)) {\\n mstore(NoContract_error_sig_ptr, NoContract_error_signature)\\n mstore(NoContract_error_token_ptr, token)\\n revert(NoContract_error_sig_ptr, NoContract_error_length)\\n }\\n\\n // Get the total number of supplied ids.\\n let idsLength := calldataload(\\n add(elementPtr, ConduitBatch1155Transfer_ids_length_offset)\\n )\\n\\n // Determine the expected offset for the amounts array.\\n let expectedAmountsOffset := add(\\n ConduitBatch1155Transfer_amounts_length_baseOffset,\\n mul(idsLength, OneWord)\\n )\\n\\n // Validate struct encoding.\\n let invalidEncoding := iszero(\\n and(\\n // ids.length == amounts.length\\n eq(\\n idsLength,\\n calldataload(add(elementPtr, expectedAmountsOffset))\\n ),\\n and(\\n // ids_offset == 0xa0\\n eq(\\n calldataload(\\n add(\\n elementPtr,\\n ConduitBatch1155Transfer_ids_head_offset\\n )\\n ),\\n ConduitBatch1155Transfer_ids_length_offset\\n ),\\n // amounts_offset == 0xc0 + ids.length*32\\n eq(\\n calldataload(\\n add(\\n elementPtr,\\n ConduitBatchTransfer_amounts_head_offset\\n )\\n ),\\n expectedAmountsOffset\\n )\\n )\\n )\\n )\\n\\n // Revert with an error if the encoding is not valid.\\n if invalidEncoding {\\n mstore(\\n Invalid1155BatchTransferEncoding_ptr,\\n Invalid1155BatchTransferEncoding_selector\\n )\\n revert(\\n Invalid1155BatchTransferEncoding_ptr,\\n Invalid1155BatchTransferEncoding_length\\n )\\n }\\n\\n // Update the offset position for the next loop\\n nextElementHeadPtr := add(nextElementHeadPtr, OneWord)\\n\\n // Copy the first section of calldata (before dynamic values).\\n calldatacopy(\\n BatchTransfer1155Params_ptr,\\n add(elementPtr, ConduitBatch1155Transfer_from_offset),\\n ConduitBatch1155Transfer_usable_head_size\\n )\\n\\n // Determine size of calldata required for ids and amounts. Note\\n // that the size includes both lengths as well as the data.\\n let idsAndAmountsSize := add(TwoWords, mul(idsLength, TwoWords))\\n\\n // Update the offset for the data array in memory.\\n mstore(\\n BatchTransfer1155Params_data_head_ptr,\\n add(\\n BatchTransfer1155Params_ids_length_offset,\\n idsAndAmountsSize\\n )\\n )\\n\\n // Set the length of the data array in memory to zero.\\n mstore(\\n add(\\n BatchTransfer1155Params_data_length_basePtr,\\n idsAndAmountsSize\\n ),\\n 0\\n )\\n\\n // Determine the total calldata size for the call to transfer.\\n let transferDataSize := add(\\n BatchTransfer1155Params_calldata_baseSize,\\n idsAndAmountsSize\\n )\\n\\n // Copy second section of calldata (including dynamic values).\\n calldatacopy(\\n BatchTransfer1155Params_ids_length_ptr,\\n add(elementPtr, ConduitBatch1155Transfer_ids_length_offset),\\n idsAndAmountsSize\\n )\\n\\n // Perform the call to transfer 1155 tokens.\\n let success := call(\\n gas(),\\n token,\\n 0,\\n ConduitBatch1155Transfer_from_offset, // Data portion start.\\n transferDataSize, // Location of the length of callData.\\n 0,\\n 0\\n )\\n\\n // If the transfer reverted:\\n if iszero(success) {\\n // If it returned a message, bubble it up as long as\\n // sufficient gas remains to do so:\\n if returndatasize() {\\n // Ensure that sufficient gas is available to copy\\n // returndata while expanding memory where necessary.\\n // Start by computing word size of returndata and\\n // allocated memory. Round up to the nearest full word.\\n let returnDataWords := div(\\n add(returndatasize(), AlmostOneWord),\\n OneWord\\n )\\n\\n // Note: use transferDataSize in place of msize() to\\n // work around a Yul warning that prevents accessing\\n // msize directly when the IR pipeline is activated.\\n // The free memory pointer is not used here because\\n // this function does almost all memory management\\n // manually and does not update it, and transferDataSize\\n // should be the largest memory value used (unless a\\n // previous batch was larger).\\n let msizeWords := div(transferDataSize, OneWord)\\n\\n // Next, compute the cost of the returndatacopy.\\n let cost := mul(CostPerWord, returnDataWords)\\n\\n // Then, compute cost of new memory allocation.\\n if gt(returnDataWords, msizeWords) {\\n cost := add(\\n cost,\\n add(\\n mul(\\n sub(returnDataWords, msizeWords),\\n CostPerWord\\n ),\\n div(\\n sub(\\n mul(\\n returnDataWords,\\n returnDataWords\\n ),\\n mul(msizeWords, msizeWords)\\n ),\\n MemoryExpansionCoefficient\\n )\\n )\\n )\\n }\\n\\n // Finally, add a small constant and compare to gas\\n // remaining; bubble up the revert data if enough gas is\\n // still available.\\n if lt(add(cost, ExtraGasBuffer), gas()) {\\n // Copy returndata to memory; overwrite existing.\\n returndatacopy(0, 0, returndatasize())\\n\\n // Revert with memory region containing returndata.\\n revert(0, returndatasize())\\n }\\n }\\n\\n // Set the error signature.\\n mstore(\\n 0,\\n ERC1155BatchTransferGenericFailure_error_signature\\n )\\n\\n // Write the token.\\n mstore(ERC1155BatchTransferGenericFailure_token_ptr, token)\\n\\n // Increase the offset to ids by 32.\\n mstore(\\n BatchTransfer1155Params_ids_head_ptr,\\n ERC1155BatchTransferGenericFailure_ids_offset\\n )\\n\\n // Increase the offset to amounts by 32.\\n mstore(\\n BatchTransfer1155Params_amounts_head_ptr,\\n add(\\n OneWord,\\n mload(BatchTransfer1155Params_amounts_head_ptr)\\n )\\n )\\n\\n // Return modified region. The total size stays the same as\\n // `token` uses the same number of bytes as `data.length`.\\n revert(0, transferDataSize)\\n }\\n }\\n\\n // Reset the free memory pointer to the default value; memory must\\n // be assumed to be dirtied and not reused from this point forward.\\n // Also note that the zero slot is not reset to zero, meaning empty\\n // arrays cannot be safely created or utilized until it is restored.\\n mstore(FreeMemoryPointerSlot, DefaultFreeMemoryPointer)\\n }\\n }\\n}\\n\",\"keccak256\":\"0xfcfa2be72ad8a3c2c096f9dc892b7040b9efc13315fc283ffe1a407d1c974ad3\",\"license\":\"MIT\"},\"contracts/lib/TokenTransferrerConstants.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.7;\\n\\n/*\\n * -------------------------- Disambiguation & Other Notes ---------------------\\n * - The term \\\"head\\\" is used as it is in the documentation for ABI encoding,\\n * but only in reference to dynamic types, i.e. it always refers to the\\n * offset or pointer to the body of a dynamic type. In calldata, the head\\n * is always an offset (relative to the parent object), while in memory,\\n * the head is always the pointer to the body. More information found here:\\n * https://docs.soliditylang.org/en/v0.8.14/abi-spec.html#argument-encoding\\n * - Note that the length of an array is separate from and precedes the\\n * head of the array.\\n *\\n * - The term \\\"body\\\" is used in place of the term \\\"head\\\" used in the ABI\\n * documentation. It refers to the start of the data for a dynamic type,\\n * e.g. the first word of a struct or the first word of the first element\\n * in an array.\\n *\\n * - The term \\\"pointer\\\" is used to describe the absolute position of a value\\n * and never an offset relative to another value.\\n * - The suffix \\\"_ptr\\\" refers to a memory pointer.\\n * - The suffix \\\"_cdPtr\\\" refers to a calldata pointer.\\n *\\n * - The term \\\"offset\\\" is used to describe the position of a value relative\\n * to some parent value. For example, OrderParameters_conduit_offset is the\\n * offset to the \\\"conduit\\\" value in the OrderParameters struct relative to\\n * the start of the body.\\n * - Note: Offsets are used to derive pointers.\\n *\\n * - Some structs have pointers defined for all of their fields in this file.\\n * Lines which are commented out are fields that are not used in the\\n * codebase but have been left in for readability.\\n */\\n\\nuint256 constant AlmostOneWord = 0x1f;\\nuint256 constant OneWord = 0x20;\\nuint256 constant TwoWords = 0x40;\\nuint256 constant ThreeWords = 0x60;\\n\\nuint256 constant FreeMemoryPointerSlot = 0x40;\\nuint256 constant ZeroSlot = 0x60;\\nuint256 constant DefaultFreeMemoryPointer = 0x80;\\n\\nuint256 constant Slot0x80 = 0x80;\\nuint256 constant Slot0xA0 = 0xa0;\\nuint256 constant Slot0xC0 = 0xc0;\\n\\n// abi.encodeWithSignature(\\\"transferFrom(address,address,uint256)\\\")\\nuint256 constant ERC20_transferFrom_signature = (\\n 0x23b872dd00000000000000000000000000000000000000000000000000000000\\n);\\nuint256 constant ERC20_transferFrom_sig_ptr = 0x0;\\nuint256 constant ERC20_transferFrom_from_ptr = 0x04;\\nuint256 constant ERC20_transferFrom_to_ptr = 0x24;\\nuint256 constant ERC20_transferFrom_amount_ptr = 0x44;\\nuint256 constant ERC20_transferFrom_length = 0x64; // 4 + 32 * 3 == 100\\n\\n// abi.encodeWithSignature(\\n// \\\"safeTransferFrom(address,address,uint256,uint256,bytes)\\\"\\n// )\\nuint256 constant ERC1155_safeTransferFrom_signature = (\\n 0xf242432a00000000000000000000000000000000000000000000000000000000\\n);\\nuint256 constant ERC1155_safeTransferFrom_sig_ptr = 0x0;\\nuint256 constant ERC1155_safeTransferFrom_from_ptr = 0x04;\\nuint256 constant ERC1155_safeTransferFrom_to_ptr = 0x24;\\nuint256 constant ERC1155_safeTransferFrom_id_ptr = 0x44;\\nuint256 constant ERC1155_safeTransferFrom_amount_ptr = 0x64;\\nuint256 constant ERC1155_safeTransferFrom_data_offset_ptr = 0x84;\\nuint256 constant ERC1155_safeTransferFrom_data_length_ptr = 0xa4;\\nuint256 constant ERC1155_safeTransferFrom_length = 0xc4; // 4 + 32 * 6 == 196\\nuint256 constant ERC1155_safeTransferFrom_data_length_offset = 0xa0;\\n\\n// abi.encodeWithSignature(\\n// \\\"safeBatchTransferFrom(address,address,uint256[],uint256[],bytes)\\\"\\n// )\\nuint256 constant ERC1155_safeBatchTransferFrom_signature = (\\n 0x2eb2c2d600000000000000000000000000000000000000000000000000000000\\n);\\n\\nbytes4 constant ERC1155_safeBatchTransferFrom_selector = bytes4(\\n bytes32(ERC1155_safeBatchTransferFrom_signature)\\n);\\n\\nuint256 constant ERC721_transferFrom_signature = ERC20_transferFrom_signature;\\nuint256 constant ERC721_transferFrom_sig_ptr = 0x0;\\nuint256 constant ERC721_transferFrom_from_ptr = 0x04;\\nuint256 constant ERC721_transferFrom_to_ptr = 0x24;\\nuint256 constant ERC721_transferFrom_id_ptr = 0x44;\\nuint256 constant ERC721_transferFrom_length = 0x64; // 4 + 32 * 3 == 100\\n\\n// abi.encodeWithSignature(\\\"NoContract(address)\\\")\\nuint256 constant NoContract_error_signature = (\\n 0x5f15d67200000000000000000000000000000000000000000000000000000000\\n);\\nuint256 constant NoContract_error_sig_ptr = 0x0;\\nuint256 constant NoContract_error_token_ptr = 0x4;\\nuint256 constant NoContract_error_length = 0x24; // 4 + 32 == 36\\n\\n// abi.encodeWithSignature(\\n// \\\"TokenTransferGenericFailure(address,address,address,uint256,uint256)\\\"\\n// )\\nuint256 constant TokenTransferGenericFailure_error_signature = (\\n 0xf486bc8700000000000000000000000000000000000000000000000000000000\\n);\\nuint256 constant TokenTransferGenericFailure_error_sig_ptr = 0x0;\\nuint256 constant TokenTransferGenericFailure_error_token_ptr = 0x4;\\nuint256 constant TokenTransferGenericFailure_error_from_ptr = 0x24;\\nuint256 constant TokenTransferGenericFailure_error_to_ptr = 0x44;\\nuint256 constant TokenTransferGenericFailure_error_id_ptr = 0x64;\\nuint256 constant TokenTransferGenericFailure_error_amount_ptr = 0x84;\\n\\n// 4 + 32 * 5 == 164\\nuint256 constant TokenTransferGenericFailure_error_length = 0xa4;\\n\\n// abi.encodeWithSignature(\\n// \\\"BadReturnValueFromERC20OnTransfer(address,address,address,uint256)\\\"\\n// )\\nuint256 constant BadReturnValueFromERC20OnTransfer_error_signature = (\\n 0x9889192300000000000000000000000000000000000000000000000000000000\\n);\\nuint256 constant BadReturnValueFromERC20OnTransfer_error_sig_ptr = 0x0;\\nuint256 constant BadReturnValueFromERC20OnTransfer_error_token_ptr = 0x4;\\nuint256 constant BadReturnValueFromERC20OnTransfer_error_from_ptr = 0x24;\\nuint256 constant BadReturnValueFromERC20OnTransfer_error_to_ptr = 0x44;\\nuint256 constant BadReturnValueFromERC20OnTransfer_error_amount_ptr = 0x64;\\n\\n// 4 + 32 * 4 == 132\\nuint256 constant BadReturnValueFromERC20OnTransfer_error_length = 0x84;\\n\\nuint256 constant ExtraGasBuffer = 0x20;\\nuint256 constant CostPerWord = 3;\\nuint256 constant MemoryExpansionCoefficient = 0x200;\\n\\n// Values are offset by 32 bytes in order to write the token to the beginning\\n// in the event of a revert\\nuint256 constant BatchTransfer1155Params_ptr = 0x24;\\nuint256 constant BatchTransfer1155Params_ids_head_ptr = 0x64;\\nuint256 constant BatchTransfer1155Params_amounts_head_ptr = 0x84;\\nuint256 constant BatchTransfer1155Params_data_head_ptr = 0xa4;\\nuint256 constant BatchTransfer1155Params_data_length_basePtr = 0xc4;\\nuint256 constant BatchTransfer1155Params_calldata_baseSize = 0xc4;\\n\\nuint256 constant BatchTransfer1155Params_ids_length_ptr = 0xc4;\\n\\nuint256 constant BatchTransfer1155Params_ids_length_offset = 0xa0;\\nuint256 constant BatchTransfer1155Params_amounts_length_baseOffset = 0xc0;\\nuint256 constant BatchTransfer1155Params_data_length_baseOffset = 0xe0;\\n\\nuint256 constant ConduitBatch1155Transfer_usable_head_size = 0x80;\\n\\nuint256 constant ConduitBatch1155Transfer_from_offset = 0x20;\\nuint256 constant ConduitBatch1155Transfer_ids_head_offset = 0x60;\\nuint256 constant ConduitBatch1155Transfer_amounts_head_offset = 0x80;\\nuint256 constant ConduitBatch1155Transfer_ids_length_offset = 0xa0;\\nuint256 constant ConduitBatch1155Transfer_amounts_length_baseOffset = 0xc0;\\nuint256 constant ConduitBatch1155Transfer_calldata_baseSize = 0xc0;\\n\\n// Note: abbreviated version of above constant to adhere to line length limit.\\nuint256 constant ConduitBatchTransfer_amounts_head_offset = 0x80;\\n\\nuint256 constant Invalid1155BatchTransferEncoding_ptr = 0x00;\\nuint256 constant Invalid1155BatchTransferEncoding_length = 0x04;\\nuint256 constant Invalid1155BatchTransferEncoding_selector = (\\n 0xeba2084c00000000000000000000000000000000000000000000000000000000\\n);\\n\\nuint256 constant ERC1155BatchTransferGenericFailure_error_signature = (\\n 0xafc445e200000000000000000000000000000000000000000000000000000000\\n);\\nuint256 constant ERC1155BatchTransferGenericFailure_token_ptr = 0x04;\\nuint256 constant ERC1155BatchTransferGenericFailure_ids_offset = 0xc0;\\n\",\"keccak256\":\"0xb55807b4999544c4e336a9ea22a963ed50620522b5406d0cd8d5b6d790a2a322\",\"license\":\"MIT\"},\"contracts/lib/Verifiers.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.13;\\n\\nimport { OrderStatus } from \\\"./ConsiderationStructs.sol\\\";\\n\\nimport { Assertions } from \\\"./Assertions.sol\\\";\\n\\nimport { SignatureVerification } from \\\"./SignatureVerification.sol\\\";\\n\\n/**\\n * @title Verifiers\\n * @author 0age\\n * @notice Verifiers contains functions for performing verifications.\\n */\\ncontract Verifiers is Assertions, SignatureVerification {\\n /**\\n * @dev Derive and set hashes, reference chainId, and associated domain\\n * separator during deployment.\\n *\\n * @param conduitController A contract that deploys conduits, or proxies\\n * that may optionally be used to transfer approved\\n * ERC20/721/1155 tokens.\\n */\\n constructor(address conduitController) Assertions(conduitController) {}\\n\\n /**\\n * @dev Internal view function to ensure that the current time falls within\\n * an order's valid timespan.\\n *\\n * @param startTime The time at which the order becomes active.\\n * @param endTime The time at which the order becomes inactive.\\n * @param revertOnInvalid A boolean indicating whether to revert if the\\n * order is not active.\\n *\\n * @return valid A boolean indicating whether the order is active.\\n */\\n function _verifyTime(\\n uint256 startTime,\\n uint256 endTime,\\n bool revertOnInvalid\\n ) internal view returns (bool valid) {\\n // Revert if order's timespan hasn't started yet or has already ended.\\n if (startTime > block.timestamp || endTime <= block.timestamp) {\\n // Only revert if revertOnInvalid has been supplied as true.\\n if (revertOnInvalid) {\\n revert InvalidTime();\\n }\\n\\n // Return false as the order is invalid.\\n return false;\\n }\\n\\n // Return true as the order time is valid.\\n valid = true;\\n }\\n\\n /**\\n * @dev Internal view function to verify the signature of an order. An\\n * ERC-1271 fallback will be attempted if either the signature length\\n * is not 32 or 33 bytes or if the recovered signer does not match the\\n * supplied offerer. Note that in cases where a 32 or 33 byte signature\\n * is supplied, only standard ECDSA signatures that recover to a\\n * non-zero address are supported.\\n *\\n * @param offerer The offerer for the order.\\n * @param orderHash The order hash.\\n * @param signature A signature from the offerer indicating that the order\\n * has been approved.\\n */\\n function _verifySignature(\\n address offerer,\\n bytes32 orderHash,\\n bytes memory signature\\n ) internal view {\\n // Skip signature verification if the offerer is the caller.\\n if (offerer == msg.sender) {\\n return;\\n }\\n\\n // Derive EIP-712 digest using the domain separator and the order hash.\\n bytes32 digest = _deriveEIP712Digest(_domainSeparator(), orderHash);\\n\\n // Ensure that the signature for the digest is valid for the offerer.\\n _assertValidSignature(offerer, digest, signature);\\n }\\n\\n /**\\n * @dev Internal view function to validate that a given order is fillable\\n * and not cancelled based on the order status.\\n *\\n * @param orderHash The order hash.\\n * @param orderStatus The status of the order, including whether it has\\n * been cancelled and the fraction filled.\\n * @param onlyAllowUnused A boolean flag indicating whether partial fills\\n * are supported by the calling function.\\n * @param revertOnInvalid A boolean indicating whether to revert if the\\n * order has been cancelled or filled beyond the\\n * allowable amount.\\n *\\n * @return valid A boolean indicating whether the order is valid.\\n */\\n function _verifyOrderStatus(\\n bytes32 orderHash,\\n OrderStatus storage orderStatus,\\n bool onlyAllowUnused,\\n bool revertOnInvalid\\n ) internal view returns (bool valid) {\\n // Ensure that the order has not been cancelled.\\n if (orderStatus.isCancelled) {\\n // Only revert if revertOnInvalid has been supplied as true.\\n if (revertOnInvalid) {\\n revert OrderIsCancelled(orderHash);\\n }\\n\\n // Return false as the order status is invalid.\\n return false;\\n }\\n\\n // Read order status numerator from storage and place on stack.\\n uint256 orderStatusNumerator = orderStatus.numerator;\\n\\n // If the order is not entirely unused...\\n if (orderStatusNumerator != 0) {\\n // ensure the order has not been partially filled when not allowed.\\n if (onlyAllowUnused) {\\n // Always revert on partial fills when onlyAllowUnused is true.\\n revert OrderPartiallyFilled(orderHash);\\n }\\n // Otherwise, ensure that order has not been entirely filled.\\n else if (orderStatusNumerator >= orderStatus.denominator) {\\n // Only revert if revertOnInvalid has been supplied as true.\\n if (revertOnInvalid) {\\n revert OrderAlreadyFilled(orderHash);\\n }\\n\\n // Return false as the order status is invalid.\\n return false;\\n }\\n }\\n\\n // Return true as the order status is valid.\\n valid = true;\\n }\\n}\\n\",\"keccak256\":\"0x7069797ed5c2965df975bf026e975110df85dbee3b8d2cb52bf90fa313185ab8\",\"license\":\"MIT\"},\"contracts/lib/ZoneInteraction.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity >=0.8.13;\\n\\nimport { ZoneInterface } from \\\"../interfaces/ZoneInterface.sol\\\";\\n\\nimport { OrderType } from \\\"./ConsiderationEnums.sol\\\";\\n\\n// prettier-ignore\\nimport { AdvancedOrder, CriteriaResolver } from \\\"./ConsiderationStructs.sol\\\";\\n\\nimport \\\"./ConsiderationConstants.sol\\\";\\n\\n// prettier-ignore\\nimport {\\n ZoneInteractionErrors\\n} from \\\"../interfaces/ZoneInteractionErrors.sol\\\";\\n\\nimport { LowLevelHelpers } from \\\"./LowLevelHelpers.sol\\\";\\n\\n/**\\n * @title ZoneInteraction\\n * @author 0age\\n * @notice ZoneInteraction contains logic related to interacting with zones.\\n */\\ncontract ZoneInteraction is ZoneInteractionErrors, LowLevelHelpers {\\n /**\\n * @dev Internal view function to determine if an order has a restricted\\n * order type and, if so, to ensure that either the offerer or the zone\\n * are the fulfiller or that a staticcall to `isValidOrder` on the zone\\n * returns a magic value indicating that the order is currently valid.\\n *\\n * @param orderHash The hash of the order.\\n * @param zoneHash The hash to provide upon calling the zone.\\n * @param orderType The type of the order.\\n * @param offerer The offerer in question.\\n * @param zone The zone in question.\\n */\\n function _assertRestrictedBasicOrderValidity(\\n bytes32 orderHash,\\n bytes32 zoneHash,\\n OrderType orderType,\\n address offerer,\\n address zone\\n ) internal view {\\n // Order type 2-3 require zone or offerer be caller or zone to approve.\\n if (\\n uint256(orderType) > 1 &&\\n msg.sender != zone &&\\n msg.sender != offerer\\n ) {\\n // Perform minimal staticcall to the zone.\\n _callIsValidOrder(zone, orderHash, offerer, zoneHash);\\n }\\n }\\n\\n function _callIsValidOrder(\\n address zone,\\n bytes32 orderHash,\\n address offerer,\\n bytes32 zoneHash\\n ) internal view {\\n // Perform minimal staticcall to the zone.\\n bool success = _staticcall(\\n zone,\\n abi.encodeWithSelector(\\n ZoneInterface.isValidOrder.selector,\\n orderHash,\\n msg.sender,\\n offerer,\\n zoneHash\\n )\\n );\\n\\n // Ensure call was successful and returned the correct magic value.\\n _assertIsValidOrderStaticcallSuccess(success, orderHash);\\n }\\n\\n /**\\n * @dev Internal view function to determine whether an order is a restricted\\n * order and, if so, to ensure that it was either submitted by the\\n * offerer or the zone for the order, or that the zone returns the\\n * expected magic value upon performing a staticcall to `isValidOrder`\\n * or `isValidOrderIncludingExtraData` depending on whether the order\\n * fulfillment specifies extra data or criteria resolvers.\\n *\\n * @param advancedOrder The advanced order in question.\\n * @param criteriaResolvers An array where each element contains a reference\\n * to a specific offer or consideration, a token\\n * identifier, and a proof that the supplied token\\n * identifier is contained in the order's merkle\\n * root. Note that a criteria of zero indicates\\n * that any (transferable) token identifier is\\n * valid and that no proof needs to be supplied.\\n * @param priorOrderHashes The order hashes of each order supplied prior to\\n * the current order as part of a \\\"match\\\" variety\\n * of order fulfillment (e.g. this array will be\\n * empty for single or \\\"fulfill available\\\").\\n * @param orderHash The hash of the order.\\n * @param zoneHash The hash to provide upon calling the zone.\\n * @param orderType The type of the order.\\n * @param offerer The offerer in question.\\n * @param zone The zone in question.\\n */\\n function _assertRestrictedAdvancedOrderValidity(\\n AdvancedOrder memory advancedOrder,\\n CriteriaResolver[] memory criteriaResolvers,\\n bytes32[] memory priorOrderHashes,\\n bytes32 orderHash,\\n bytes32 zoneHash,\\n OrderType orderType,\\n address offerer,\\n address zone\\n ) internal view {\\n // Order type 2-3 require zone or offerer be caller or zone to approve.\\n if (\\n uint256(orderType) > 1 &&\\n msg.sender != zone &&\\n msg.sender != offerer\\n ) {\\n // If no extraData or criteria resolvers are supplied...\\n if (\\n advancedOrder.extraData.length == 0 &&\\n criteriaResolvers.length == 0\\n ) {\\n // Perform minimal staticcall to the zone.\\n _callIsValidOrder(zone, orderHash, offerer, zoneHash);\\n } else {\\n // Otherwise, extra data or criteria resolvers were supplied; in\\n // that event, perform a more verbose staticcall to the zone.\\n bool success = _staticcall(\\n zone,\\n abi.encodeWithSelector(\\n ZoneInterface.isValidOrderIncludingExtraData.selector,\\n orderHash,\\n msg.sender,\\n advancedOrder,\\n priorOrderHashes,\\n criteriaResolvers\\n )\\n );\\n\\n // Ensure call was successful and returned correct magic value.\\n _assertIsValidOrderStaticcallSuccess(success, orderHash);\\n }\\n }\\n }\\n\\n /**\\n * @dev Internal view function to ensure that a staticcall to `isValidOrder`\\n * or `isValidOrderIncludingExtraData` as part of validating a\\n * restricted order that was not submitted by the named offerer or zone\\n * was successful and returned the required magic value.\\n *\\n * @param success A boolean indicating the status of the staticcall.\\n * @param orderHash The order hash of the order in question.\\n */\\n function _assertIsValidOrderStaticcallSuccess(\\n bool success,\\n bytes32 orderHash\\n ) internal view {\\n // If the call failed...\\n if (!success) {\\n // Revert and pass reason along if one was returned.\\n _revertWithReasonIfOneIsReturned();\\n\\n // Otherwise, revert with a generic error message.\\n revert InvalidRestrictedOrder(orderHash);\\n }\\n\\n // Ensure result was extracted and matches isValidOrder magic value.\\n if (_doesNotMatchMagic(ZoneInterface.isValidOrder.selector)) {\\n revert InvalidRestrictedOrder(orderHash);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x3549d01e5424368ab2bc9c89f6c69c125f7a0920cc06900e485e8a715465e11f\",\"license\":\"MIT\"}},\"version\":1}", + "bytecode": "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", + "deployedBytecode": "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", + "devdoc": { + "author": "0age (0age.eth)", + "custom:coauthor": "d1ll0n (d1ll0n.eth)transmissions11 (t11s.eth)", + "custom:contributor": "Kartik (slokh.eth)LeFevre (lefevre.eth)Joseph Schiarizzi (CupOJoseph.eth)Aspyn Palatnick (stuckinaboot.eth)James Wenzel (emo.eth)Stephan Min (stephanm.eth)Ryan Ghods (ralxz.eth)hack3r-0m (hack3r-0m.eth)Diego Estevez (antidiego.eth)Chomtana (chomtana.eth)Saw-mon and Natalie (sawmonandnatalie.eth)0xBeans (0xBeans.eth)0x4non (punkdev.eth)Laurence E. Day (norsefire.eth)vectorized.eth (vectorized.eth)karmacoma (karmacoma.eth)horsefacts (horsefacts.eth)UncarvedBlock (uncarvedblock.eth)Zoraiz Mahmood (zorz.eth)William Poulin (wpoulin.eth)Rajiv Patel-O'Connor (rajivpoc.eth)tserg (tserg.eth)cygaar (cygaar.eth)Meta0xNull (meta0xnull.eth)gpersoon (gpersoon.eth)Matt Solomon (msolomon.eth)Weikang Song (weikangs.eth)zer0dot (zer0dot.eth)Mudit Gupta (mudit.eth)leonardoalt (leoalt.eth)cmichel (cmichel.eth)PraneshASP (pranesh.eth)JasperAlexander (jasperalexander.eth)Ellahi (ellahi.eth)zaz (1zaz1.eth)berndartmueller (berndartmueller.eth)dmfxyz (dmfxyz.eth)daltoncoder (dontkillrobots.eth)0xf4ce (0xf4ce.eth)phaze (phaze.eth)hrkrshnn (hrkrshnn.eth)axic (axic.eth)leastwood (leastwood.eth)0xsanson (sanson.eth)blockdev (blockd3v.eth)fiveoutofnine (fiveoutofnine.eth)shuklaayush (shuklaayush.eth)0xPatissierpcaversaccioDavid Eibercsanuragjainsach1r0twojoy0ori_dabushDaniel GelfandokkothejawaFlameHorizonvdrgdmitriiabokeh-ethasutorufosrfart(rfa)Riley Holterhusbig-tech-sux", + "custom:version": "1.1", + "errors": { + "BadContractSignature()": [ + { + "details": "Revert with an error when an EIP-1271 call to an account fails." + } + ], + "BadFraction()": [ + { + "details": "Revert with an error when supplying a fraction with a value of zero for the numerator or denominator, or one where the numerator exceeds the denominator." + } + ], + "BadReturnValueFromERC20OnTransfer(address,address,address,uint256)": [ + { + "details": "Revert with an error when an ERC20 token transfer returns a falsey value.", + "params": { + "amount": "The amount for the attempted ERC20 transfer.", + "from": "The source of the attempted ERC20 transfer.", + "to": "The recipient of the attempted ERC20 transfer.", + "token": "The token for which the ERC20 transfer was attempted." + } + } + ], + "BadSignatureV(uint8)": [ + { + "details": "Revert with an error when a signature that does not contain a v value of 27 or 28 has been supplied.", + "params": { + "v": "The invalid v value." + } + } + ], + "ConsiderationCriteriaResolverOutOfRange()": [ + { + "details": "Revert with an error when providing a criteria resolver that refers to an order with a consideration item that has not been supplied." + } + ], + "ConsiderationNotMet(uint256,uint256,uint256)": [ + { + "details": "Revert with an error if a consideration amount has not been fully zeroed out after applying all fulfillments.", + "params": { + "considerationIndex": "The index of the consideration item on the order.", + "orderIndex": "The index of the order with the consideration item with a shortfall.", + "shortfallAmount": "The unfulfilled consideration amount." + } + } + ], + "CriteriaNotEnabledForItem()": [ + { + "details": "Revert with an error when providing a criteria resolver that refers to an order with an item that does not expect a criteria to be resolved." + } + ], + "ERC1155BatchTransferGenericFailure(address,address,address,uint256[],uint256[])": [ + { + "details": "Revert with an error when a batch ERC1155 token transfer reverts.", + "params": { + "amounts": "The amounts for the attempted transfer.", + "from": "The source of the attempted transfer.", + "identifiers": "The identifiers for the attempted transfer.", + "to": "The recipient of the attempted transfer.", + "token": "The token for which the transfer was attempted." + } + } + ], + "EtherTransferGenericFailure(address,uint256)": [ + { + "details": "Revert with an error when an ether transfer reverts." + } + ], + "InexactFraction()": [ + { + "details": "Revert with an error when attempting to apply a fraction as part of a partial fill that does not divide the target amount cleanly." + } + ], + "InsufficientEtherSupplied()": [ + { + "details": "Revert with an error when insufficient ether is supplied as part of msg.value when fulfilling orders." + } + ], + "Invalid1155BatchTransferEncoding()": [ + { + "details": "Revert with an error when attempting to execute an 1155 batch transfer using calldata not produced by default ABI encoding or with different lengths for ids and amounts arrays." + } + ], + "InvalidBasicOrderParameterEncoding()": [ + { + "details": "Revert with an error when attempting to fill a basic order using calldata not produced by default ABI encoding." + } + ], + "InvalidCallToConduit(address)": [ + { + "details": "Revert with an error when a call to a conduit fails with revert data that is too expensive to return." + } + ], + "InvalidCanceller()": [ + { + "details": "Revert with an error when attempting to cancel an order as a caller other than the indicated offerer or zone." + } + ], + "InvalidConduit(bytes32,address)": [ + { + "details": "Revert with an error when attempting to fill an order referencing an invalid conduit (i.e. one that has not been deployed)." + } + ], + "InvalidERC721TransferAmount()": [ + { + "details": "Revert with an error when an ERC721 transfer with amount other than one is attempted." + } + ], + "InvalidFulfillmentComponentData()": [ + { + "details": "Revert with an error when an order or item index are out of range or a fulfillment component does not match the type, token, identifier, or conduit preference of the initial consideration item." + } + ], + "InvalidMsgValue(uint256)": [ + { + "details": "Revert with an error when a caller attempts to supply callvalue to a non-payable basic order route or does not supply any callvalue to a payable basic order route." + } + ], + "InvalidNativeOfferItem()": [ + { + "details": "Revert with an error when attempting to fulfill an order with an offer for ETH outside of matching orders." + } + ], + "InvalidProof()": [ + { + "details": "Revert with an error when providing a criteria resolver that contains an invalid proof with respect to the given item and chosen identifier." + } + ], + "InvalidRestrictedOrder(bytes32)": [ + { + "details": "Revert with an error when attempting to fill an order that specifies a restricted submitter as its order type when not submitted by either the offerer or the order's zone or approved as valid by the zone in question via a staticcall to `isValidOrder`.", + "params": { + "orderHash": "The order hash for the invalid restricted order." + } + } + ], + "InvalidSignature()": [ + { + "details": "Revert with an error when a signer cannot be recovered from the supplied signature." + } + ], + "InvalidSigner()": [ + { + "details": "Revert with an error when the signer recovered by the supplied signature does not match the offerer or an allowed EIP-1271 signer as specified by the offerer in the event they are a contract." + } + ], + "InvalidTime()": [ + { + "details": "Revert with an error when attempting to fill an order outside the specified start time and end time." + } + ], + "MismatchedFulfillmentOfferAndConsiderationComponents()": [ + { + "details": "Revert with an error when the initial offer item named by a fulfillment component does not match the type, token, identifier, or conduit preference of the initial consideration item." + } + ], + "MissingFulfillmentComponentOnAggregation(uint8)": [ + { + "details": "Revert with an error when a fulfillment is provided that does not declare at least one component as part of a call to fulfill available orders." + } + ], + "MissingItemAmount()": [ + { + "details": "Revert with an error when attempting to fulfill an order where an item has an amount of zero." + } + ], + "MissingOriginalConsiderationItems()": [ + { + "details": "Revert with an error when an order is supplied for fulfillment with a consideration array that is shorter than the original array." + } + ], + "NoContract(address)": [ + { + "details": "Revert with an error when an account being called as an assumed contract does not have code and returns no data.", + "params": { + "account": "The account that should contain code." + } + } + ], + "NoReentrantCalls()": [ + { + "details": "Revert with an error when a caller attempts to reenter a protected function." + } + ], + "NoSpecifiedOrdersAvailable()": [ + { + "details": "Revert with an error when attempting to fulfill any number of available orders when none are fulfillable." + } + ], + "OfferAndConsiderationRequiredOnFulfillment()": [ + { + "details": "Revert with an error when a fulfillment is provided that does not declare at least one offer component and at least one consideration component." + } + ], + "OfferCriteriaResolverOutOfRange()": [ + { + "details": "Revert with an error when providing a criteria resolver that refers to an order with an offer item that has not been supplied." + } + ], + "OrderAlreadyFilled(bytes32)": [ + { + "details": "Revert with an error when attempting to fill an order that has already been fully filled.", + "params": { + "orderHash": "The order hash on which a fill was attempted." + } + } + ], + "OrderCriteriaResolverOutOfRange()": [ + { + "details": "Revert with an error when providing a criteria resolver that refers to an order that has not been supplied." + } + ], + "OrderIsCancelled(bytes32)": [ + { + "details": "Revert with an error when attempting to fill an order that has been cancelled.", + "params": { + "orderHash": "The hash of the cancelled order." + } + } + ], + "OrderPartiallyFilled(bytes32)": [ + { + "details": "Revert with an error when attempting to fill a basic order that has been partially filled.", + "params": { + "orderHash": "The hash of the partially used order." + } + } + ], + "PartialFillsNotEnabledForOrder()": [ + { + "details": "Revert with an error when a partial fill is attempted on an order that does not specify partial fill support in its order type." + } + ], + "TokenTransferGenericFailure(address,address,address,uint256,uint256)": [ + { + "details": "Revert with an error when an ERC20, ERC721, or ERC1155 token transfer reverts.", + "params": { + "amount": "The amount for the attempted transfer.", + "from": "The source of the attempted transfer.", + "identifier": "The identifier for the attempted transfer.", + "to": "The recipient of the attempted transfer.", + "token": "The token for which the transfer was attempted." + } + } + ], + "UnresolvedConsiderationCriteria()": [ + { + "details": "Revert with an error if a consideration item still has unresolved criteria after applying all criteria resolvers." + } + ], + "UnresolvedOfferCriteria()": [ + { + "details": "Revert with an error if an offer item still has unresolved criteria after applying all criteria resolvers." + } + ], + "UnusedItemParameters()": [ + { + "details": "Revert with an error when attempting to fulfill an order where an item has unused parameters. This includes both the token and the identifier parameters for native transfers as well as the identifier parameter for ERC20 transfers. Note that the conduit does not perform this check, leaving it up to the calling channel to enforce when desired." + } + ] + }, + "kind": "dev", + "methods": { + "cancel((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256)[])": { + "params": { + "orders": "The orders to cancel." + }, + "returns": { + "cancelled": "A boolean indicating whether the supplied orders have been successfully cancelled." + } + }, + "constructor": { + "params": { + "conduitController": "A contract that deploys conduits, or proxies that may optionally be used to transfer approved ERC20/721/1155 tokens." + } + }, + "fulfillAdvancedOrder(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),uint120,uint120,bytes,bytes),(uint256,uint8,uint256,uint256,bytes32[])[],bytes32,address)": { + "params": { + "advancedOrder": "The order to fulfill along with the fraction of the order to attempt to fill. Note that both the offerer and the fulfiller must first approve this contract (or their conduit if indicated by the order) to transfer any relevant tokens on their behalf and that contracts must implement `onERC1155Received` to receive ERC1155 tokens as consideration. Also note that all offer and consideration components must have no remainder after multiplication of the respective amount with the supplied fraction for the partial fill to be considered valid.", + "criteriaResolvers": "An array where each element contains a reference to a specific offer or consideration, a token identifier, and a proof that the supplied token identifier is contained in the merkle root held by the item in question's criteria element. Note that an empty criteria indicates that any (transferable) token identifier on the token in question is valid and that no associated proof needs to be supplied.", + "fulfillerConduitKey": "A bytes32 value indicating what conduit, if any, to source the fulfiller's token approvals from. The zero hash signifies that no conduit should be used (and direct approvals set on Consideration).", + "recipient": "The intended recipient for all received items, with `address(0)` indicating that the caller should receive the items." + }, + "returns": { + "fulfilled": "A boolean indicating whether the order has been successfully fulfilled." + } + }, + "fulfillAvailableAdvancedOrders(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),uint120,uint120,bytes,bytes)[],(uint256,uint8,uint256,uint256,bytes32[])[],(uint256,uint256)[][],(uint256,uint256)[][],bytes32,address,uint256)": { + "params": { + "advancedOrders": "The orders to fulfill along with the fraction of those orders to attempt to fill. Note that both the offerer and the fulfiller must first approve this contract (or their conduit if indicated by the order) to transfer any relevant tokens on their behalf and that contracts must implement `onERC1155Received` in order to receive ERC1155 tokens as consideration. Also note that all offer and consideration components must have no remainder after multiplication of the respective amount with the supplied fraction for an order's partial fill amount to be considered valid.", + "considerationFulfillments": "An array of FulfillmentComponent arrays indicating which consideration items to attempt to aggregate when preparing executions.", + "criteriaResolvers": "An array where each element contains a reference to a specific offer or consideration, a token identifier, and a proof that the supplied token identifier is contained in the merkle root held by the item in question's criteria element. Note that an empty criteria indicates that any (transferable) token identifier on the token in question is valid and that no associated proof needs to be supplied.", + "fulfillerConduitKey": "A bytes32 value indicating what conduit, if any, to source the fulfiller's token approvals from. The zero hash signifies that no conduit should be used (and direct approvals set on Consideration).", + "maximumFulfilled": "The maximum number of orders to fulfill.", + "offerFulfillments": "An array of FulfillmentComponent arrays indicating which offer items to attempt to aggregate when preparing executions.", + "recipient": "The intended recipient for all received items, with `address(0)` indicating that the caller should receive the items." + }, + "returns": { + "availableOrders": "An array of booleans indicating if each order with an index corresponding to the index of the returned boolean was fulfillable or not.", + "executions": " An array of elements indicating the sequence of transfers performed as part of matching the given orders." + } + }, + "fulfillAvailableOrders(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),bytes)[],(uint256,uint256)[][],(uint256,uint256)[][],bytes32,uint256)": { + "params": { + "considerationFulfillments": "An array of FulfillmentComponent arrays indicating which consideration items to attempt to aggregate when preparing executions.", + "fulfillerConduitKey": "A bytes32 value indicating what conduit, if any, to source the fulfiller's token approvals from. The zero hash signifies that no conduit should be used (and direct approvals set on Consideration).", + "maximumFulfilled": "The maximum number of orders to fulfill.", + "offerFulfillments": "An array of FulfillmentComponent arrays indicating which offer items to attempt to aggregate when preparing executions.", + "orders": "The orders to fulfill. Note that both the offerer and the fulfiller must first approve this contract (or the corresponding conduit if indicated) to transfer any relevant tokens on their behalf and that contracts must implement `onERC1155Received` to receive ERC1155 tokens as consideration." + }, + "returns": { + "availableOrders": "An array of booleans indicating if each order with an index corresponding to the index of the returned boolean was fulfillable or not.", + "executions": " An array of elements indicating the sequence of transfers performed as part of matching the given orders." + } + }, + "fulfillBasicOrder((address,uint256,uint256,address,address,address,uint256,uint256,uint8,uint256,uint256,bytes32,uint256,bytes32,bytes32,uint256,(uint256,address)[],bytes))": { + "params": { + "parameters": "Additional information on the fulfilled order. Note that the offerer and the fulfiller must first approve this contract (or their chosen conduit if indicated) before any tokens can be transferred. Also note that contract recipients of ERC1155 consideration items must implement `onERC1155Received` in order to receive those items." + }, + "returns": { + "fulfilled": "A boolean indicating whether the order has been successfully fulfilled." + } + }, + "fulfillOrder(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),bytes),bytes32)": { + "params": { + "fulfillerConduitKey": "A bytes32 value indicating what conduit, if any, to source the fulfiller's token approvals from. The zero hash signifies that no conduit should be used (and direct approvals set on Consideration).", + "order": "The order to fulfill. Note that both the offerer and the fulfiller must first approve this contract (or the corresponding conduit if indicated) to transfer any relevant tokens on their behalf and that contracts must implement `onERC1155Received` to receive ERC1155 tokens as consideration." + }, + "returns": { + "fulfilled": "A boolean indicating whether the order has been successfully fulfilled." + } + }, + "getCounter(address)": { + "params": { + "offerer": "The offerer in question." + }, + "returns": { + "counter": "The current counter." + } + }, + "getOrderHash((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256))": { + "params": { + "order": "The components of the order." + }, + "returns": { + "orderHash": "The order hash." + } + }, + "getOrderStatus(bytes32)": { + "params": { + "orderHash": "The order hash in question." + }, + "returns": { + "isCancelled": "A boolean indicating whether the order in question has been cancelled.", + "isValidated": "A boolean indicating whether the order in question has been validated (i.e. previously approved or partially filled).", + "totalFilled": "The total portion of the order that has been filled (i.e. the \"numerator\").", + "totalSize": " The total size of the order that is either filled or unfilled (i.e. the \"denominator\")." + } + }, + "incrementCounter()": { + "returns": { + "newCounter": "The new counter." + } + }, + "information()": { + "returns": { + "conduitController": "The conduit Controller set for this contract.", + "domainSeparator": " The domain separator for this contract.", + "version": " The contract version." + } + }, + "matchAdvancedOrders(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),uint120,uint120,bytes,bytes)[],(uint256,uint8,uint256,uint256,bytes32[])[],((uint256,uint256)[],(uint256,uint256)[])[])": { + "params": { + "advancedOrders": "The advanced orders to match. Note that both the offerer and fulfiller on each order must first approve this contract (or their conduit if indicated by the order) to transfer any relevant tokens on their behalf and each consideration recipient must implement `onERC1155Received` in order to receive ERC1155 tokens. Also note that the offer and consideration components for each order must have no remainder after multiplying the respective amount with the supplied fraction in order for the group of partial fills to be considered valid.", + "criteriaResolvers": "An array where each element contains a reference to a specific order as well as that order's offer or consideration, a token identifier, and a proof that the supplied token identifier is contained in the order's merkle root. Note that an empty root indicates that any (transferable) token identifier is valid and that no associated proof needs to be supplied.", + "fulfillments": "An array of elements allocating offer components to consideration components. Note that each consideration component must be fully met in order for the match operation to be valid." + }, + "returns": { + "executions": "An array of elements indicating the sequence of transfers performed as part of matching the given orders." + } + }, + "matchOrders(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),bytes)[],((uint256,uint256)[],(uint256,uint256)[])[])": { + "params": { + "fulfillments": "An array of elements allocating offer components to consideration components. Note that each consideration component must be fully met in order for the match operation to be valid.", + "orders": "The orders to match. Note that both the offerer and fulfiller on each order must first approve this contract (or their conduit if indicated by the order) to transfer any relevant tokens on their behalf and each consideration recipient must implement `onERC1155Received` in order to receive ERC1155 tokens." + }, + "returns": { + "executions": "An array of elements indicating the sequence of transfers performed as part of matching the given orders." + } + }, + "name()": { + "returns": { + "contractName": "The name of this contract." + } + }, + "validate(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),bytes)[])": { + "params": { + "orders": "The orders to validate." + }, + "returns": { + "validated": "A boolean indicating whether the supplied orders have been successfully validated." + } + } + }, + "title": "Seaport", + "version": 1 + }, + "userdoc": { + "kind": "user", + "methods": { + "cancel((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256)[])": { + "notice": "Cancel an arbitrary number of orders. Note that only the offerer or the zone of a given order may cancel it. Callers should ensure that the intended order was cancelled by calling `getOrderStatus` and confirming that `isCancelled` returns `true`." + }, + "constructor": { + "notice": "Derive and set hashes, reference chainId, and associated domain separator during deployment." + }, + "fulfillAdvancedOrder(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),uint120,uint120,bytes,bytes),(uint256,uint8,uint256,uint256,bytes32[])[],bytes32,address)": { + "notice": "Fill an order, fully or partially, with an arbitrary number of items for offer and consideration alongside criteria resolvers containing specific token identifiers and associated proofs." + }, + "fulfillAvailableAdvancedOrders(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),uint120,uint120,bytes,bytes)[],(uint256,uint8,uint256,uint256,bytes32[])[],(uint256,uint256)[][],(uint256,uint256)[][],bytes32,address,uint256)": { + "notice": "Attempt to fill a group of orders, fully or partially, with an arbitrary number of items for offer and consideration per order alongside criteria resolvers containing specific token identifiers and associated proofs. Any order that is not currently active, has already been fully filled, or has been cancelled will be omitted. Remaining offer and consideration items will then be aggregated where possible as indicated by the supplied offer and consideration component arrays and aggregated items will be transferred to the fulfiller or to each intended recipient, respectively. Note that a failing item transfer or an issue with order formatting will cause the entire batch to fail." + }, + "fulfillAvailableOrders(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),bytes)[],(uint256,uint256)[][],(uint256,uint256)[][],bytes32,uint256)": { + "notice": "Attempt to fill a group of orders, each with an arbitrary number of items for offer and consideration. Any order that is not currently active, has already been fully filled, or has been cancelled will be omitted. Remaining offer and consideration items will then be aggregated where possible as indicated by the supplied offer and consideration component arrays and aggregated items will be transferred to the fulfiller or to each intended recipient, respectively. Note that a failing item transfer or an issue with order formatting will cause the entire batch to fail. Note that this function does not support criteria-based orders or partial filling of orders (though filling the remainder of a partially-filled order is supported)." + }, + "fulfillBasicOrder((address,uint256,uint256,address,address,address,uint256,uint256,uint8,uint256,uint256,bytes32,uint256,bytes32,bytes32,uint256,(uint256,address)[],bytes))": { + "notice": "Fulfill an order offering an ERC20, ERC721, or ERC1155 item by supplying Ether (or other native tokens), ERC20 tokens, an ERC721 item, or an ERC1155 item as consideration. Six permutations are supported: Native token to ERC721, Native token to ERC1155, ERC20 to ERC721, ERC20 to ERC1155, ERC721 to ERC20, and ERC1155 to ERC20 (with native tokens supplied as msg.value). For an order to be eligible for fulfillment via this method, it must contain a single offer item (though that item may have a greater amount if the item is not an ERC721). An arbitrary number of \"additional recipients\" may also be supplied which will each receive native tokens or ERC20 items from the fulfiller as consideration. Refer to the documentation for a more comprehensive summary of how to utilize this method and what orders are compatible with it." + }, + "fulfillOrder(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),bytes),bytes32)": { + "notice": "Fulfill an order with an arbitrary number of items for offer and consideration. Note that this function does not support criteria-based orders or partial filling of orders (though filling the remainder of a partially-filled order is supported)." + }, + "getCounter(address)": { + "notice": "Retrieve the current counter for a given offerer." + }, + "getOrderHash((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256))": { + "notice": "Retrieve the order hash for a given order." + }, + "getOrderStatus(bytes32)": { + "notice": "Retrieve the status of a given order by hash, including whether the order has been cancelled or validated and the fraction of the order that has been filled." + }, + "incrementCounter()": { + "notice": "Cancel all orders from a given offerer with a given zone in bulk by incrementing a counter. Note that only the offerer may increment the counter." + }, + "information()": { + "notice": "Retrieve configuration information for this contract." + }, + "matchAdvancedOrders(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),uint120,uint120,bytes,bytes)[],(uint256,uint8,uint256,uint256,bytes32[])[],((uint256,uint256)[],(uint256,uint256)[])[])": { + "notice": "Match an arbitrary number of full or partial orders, each with an arbitrary number of items for offer and consideration, supplying criteria resolvers containing specific token identifiers and associated proofs as well as fulfillments allocating offer components to consideration components." + }, + "matchOrders(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),bytes)[],((uint256,uint256)[],(uint256,uint256)[])[])": { + "notice": "Match an arbitrary number of orders, each with an arbitrary number of items for offer and consideration along with a set of fulfillments allocating offer components to consideration components. Note that this function does not support criteria-based or partial filling of orders (though filling the remainder of a partially-filled order is supported)." + }, + "name()": { + "notice": "Retrieve the name of this contract." + }, + "validate(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),bytes)[])": { + "notice": "Validate an arbitrary number of orders, thereby registering their signatures as valid and allowing the fulfiller to skip signature verification on fulfillment. Note that validated orders may still be unfulfillable due to invalid item amounts or other factors; callers should determine whether validated orders are fulfillable by simulating the fulfillment call prior to execution. Also note that anyone can validate a signed order, but only the offerer can validate an order without supplying a signature." + } + }, + "notice": "Seaport is a generalized ETH/ERC20/ERC721/ERC1155 marketplace. It minimizes external calls to the greatest extent possible and provides lightweight methods for common routes as well as more flexible methods for composing advanced orders or groups of orders. Each order contains an arbitrary number of items that may be spent (the \"offer\") along with an arbitrary number of items that must be received back by the indicated recipients (the \"consideration\").", + "version": 1 + }, + "storageLayout": { + "storage": [ + { + "astId": 8716, + "contract": "contracts/Seaport.sol:Seaport", + "label": "_reentrancyGuard", + "offset": 0, + "slot": "0", + "type": "t_uint256" + }, + { + "astId": 5039, + "contract": "contracts/Seaport.sol:Seaport", + "label": "_counters", + "offset": 0, + "slot": "1", + "type": "t_mapping(t_address,t_uint256)" + }, + { + "astId": 8079, + "contract": "contracts/Seaport.sol:Seaport", + "label": "_orderStatus", + "offset": 0, + "slot": "2", + "type": "t_mapping(t_bytes32,t_struct(OrderStatus)4989_storage)" + } + ], + "types": { + "t_address": { + "encoding": "inplace", + "label": "address", + "numberOfBytes": "20" + }, + "t_bool": { + "encoding": "inplace", + "label": "bool", + "numberOfBytes": "1" + }, + "t_bytes32": { + "encoding": "inplace", + "label": "bytes32", + "numberOfBytes": "32" + }, + "t_mapping(t_address,t_uint256)": { + "encoding": "mapping", + "key": "t_address", + "label": "mapping(address => uint256)", + "numberOfBytes": "32", + "value": "t_uint256" + }, + "t_mapping(t_bytes32,t_struct(OrderStatus)4989_storage)": { + "encoding": "mapping", + "key": "t_bytes32", + "label": "mapping(bytes32 => struct OrderStatus)", + "numberOfBytes": "32", + "value": "t_struct(OrderStatus)4989_storage" + }, + "t_struct(OrderStatus)4989_storage": { + "encoding": "inplace", + "label": "struct OrderStatus", + "members": [ + { + "astId": 4982, + "contract": "contracts/Seaport.sol:Seaport", + "label": "isValidated", + "offset": 0, + "slot": "0", + "type": "t_bool" + }, + { + "astId": 4984, + "contract": "contracts/Seaport.sol:Seaport", + "label": "isCancelled", + "offset": 1, + "slot": "0", + "type": "t_bool" + }, + { + "astId": 4986, + "contract": "contracts/Seaport.sol:Seaport", + "label": "numerator", + "offset": 2, + "slot": "0", + "type": "t_uint120" + }, + { + "astId": 4988, + "contract": "contracts/Seaport.sol:Seaport", + "label": "denominator", + "offset": 17, + "slot": "0", + "type": "t_uint120" + } + ], + "numberOfBytes": "32" + }, + "t_uint120": { + "encoding": "inplace", + "label": "uint120", + "numberOfBytes": "15" + }, + "t_uint256": { + "encoding": "inplace", + "label": "uint256", + "numberOfBytes": "32" + } + } + } +} \ No newline at end of file diff --git a/eip-712-types/domain.js b/eip-712-types/domain.js new file mode 100644 index 00000000..3c45330f --- /dev/null +++ b/eip-712-types/domain.js @@ -0,0 +1,12 @@ +const eip712DomainType = { + EIP712Domain: [ + { name: "name", type: "string" }, + { name: "version", type: "string" }, + { name: "chainId", type: "uint256" }, + { name: "verifyingContract", type: "address" }, + ], +}; + +module.exports = Object.freeze({ + eip712DomainType, +}); diff --git a/eip-712-types/order.js b/eip-712-types/order.js new file mode 100644 index 00000000..f6af0235 --- /dev/null +++ b/eip-712-types/order.js @@ -0,0 +1,34 @@ +const orderType = { + OrderComponents: [ + { name: "offerer", type: "address" }, + { name: "zone", type: "address" }, + { name: "offer", type: "OfferItem[]" }, + { name: "consideration", type: "ConsiderationItem[]" }, + { name: "orderType", type: "uint8" }, + { name: "startTime", type: "uint256" }, + { name: "endTime", type: "uint256" }, + { name: "zoneHash", type: "bytes32" }, + { name: "salt", type: "uint256" }, + { name: "conduitKey", type: "bytes32" }, + { name: "counter", type: "uint256" }, + ], + OfferItem: [ + { name: "itemType", type: "uint8" }, + { name: "token", type: "address" }, + { name: "identifierOrCriteria", type: "uint256" }, + { name: "startAmount", type: "uint256" }, + { name: "endAmount", type: "uint256" }, + ], + ConsiderationItem: [ + { name: "itemType", type: "uint8" }, + { name: "token", type: "address" }, + { name: "identifierOrCriteria", type: "uint256" }, + { name: "startAmount", type: "uint256" }, + { name: "endAmount", type: "uint256" }, + { name: "recipient", type: "address" }, + ], +}; + +module.exports = Object.freeze({ + orderType, +}); diff --git a/hardhat-coverage.config.ts b/hardhat-coverage.config.ts new file mode 100644 index 00000000..bea7c4d8 --- /dev/null +++ b/hardhat-coverage.config.ts @@ -0,0 +1,40 @@ +import * as dotenv from "dotenv"; + +import { HardhatUserConfig, task } from "hardhat/config"; +import "@nomiclabs/hardhat-waffle"; +import "@typechain/hardhat"; +import "hardhat-gas-reporter"; +import "solidity-coverage"; + +dotenv.config(); + +// You need to export an object to set up your config +// Go to https://hardhat.org/config/ to learn more + +const config: HardhatUserConfig = { + solidity: { + compilers: [ + { + version: "0.8.14", + settings: { + viaIR: false, + optimizer: { + enabled: false, + }, + }, + }, + ], + }, + networks: { + hardhat: { + blockGasLimit: 30_000_000, + throwOnCallFailures: false, + }, + }, + gasReporter: { + enabled: process.env.REPORT_GAS !== undefined, + currency: "USD", + }, +}; + +export default config; diff --git a/hardhat.config.ts b/hardhat.config.ts new file mode 100644 index 00000000..f8e371ba --- /dev/null +++ b/hardhat.config.ts @@ -0,0 +1,138 @@ +import * as dotenv from "dotenv"; + +import { HardhatUserConfig, subtask, task } from "hardhat/config"; +import "@openzeppelin/hardhat-upgrades"; +import "@nomiclabs/hardhat-waffle"; +import "@nomiclabs/hardhat-etherscan"; +import "@nomiclabs/hardhat-ethers"; +import "@typechain/hardhat"; +import "hardhat-gas-reporter"; +import "solidity-coverage"; +import "hardhat-deploy"; +import "@tenderly/hardhat-tenderly"; + +import { TASK_COMPILE_SOLIDITY_GET_SOURCE_PATHS } from "hardhat/builtin-tasks/task-names"; + +dotenv.config(); + +let accounts; + +if (process.env.PRIVATE_KEY) { + accounts = [process.env.PRIVATE_KEY]; +} else { + accounts = { + mnemonic: + process.env.MNEMONIC || + "test test test test test test test test test test test junk", + }; +} + +// This is a sample Hardhat task. To learn how to create your own go to +// https://hardhat.org/guides/create-task.html +task("accounts", "Prints the list of accounts", async (args, { ethers }) => { + const accounts = await ethers.getSigners(); + + for (const account of accounts) { + console.log(await account.address); + } +}); + +// You need to export an object to set up your config +// Go to https://hardhat.org/config/ to learn more + +const config: HardhatUserConfig = { + solidity: { + compilers: [ + { + version: "0.8.14", + settings: { + viaIR: true, + optimizer: { + enabled: true, + runs: 19066, + }, + }, + }, + { + version: "0.6.12", + settings: { + optimizer: { + enabled: true, + runs: 200, + }, + }, + }, + { + version: "0.8.11", + settings: { + optimizer: { + enabled: true, + runs: 999999, + }, + }, + }, + ], + overrides: { + "contracts/conduit/Conduit.sol": { + version: "0.8.14", + settings: { + viaIR: true, + optimizer: { + enabled: true, + runs: 1000000, + }, + }, + }, + "contracts/conduit/ConduitController.sol": { + version: "0.8.14", + settings: { + viaIR: true, + optimizer: { + enabled: true, + runs: 1000000, + }, + }, + }, + }, + }, + etherscan: { + apiKey: process.env.ETHERSCAN_API_KEY, + }, + networks: { + hardhat: { + blockGasLimit: 30_000_000, + throwOnCallFailures: false, + allowUnlimitedContractSize: true, + }, + goerli: { + url: `https://goerli.infura.io/v3/${process.env.INFURA_API_KEY}`, + accounts, + chainId: 5, + live: true, + saveDeployments: true, + tags: ["staging"], + }, + }, + namedAccounts: { + deployer: { + default: 0, + }, + alice: { + default: 1, + }, + bob: { + default: 2, + }, + carol: { + default: 3, + }, + }, + gasReporter: { + enabled: process.env.REPORT_GAS !== undefined, + currency: "USD", + }, + // specify separate cache for hardhat, since it could possibly conflict with foundry's + paths: { cache: "hh-cache" }, +}; + +export default config; diff --git a/package.json b/package.json new file mode 100644 index 00000000..f568e884 --- /dev/null +++ b/package.json @@ -0,0 +1,138 @@ +{ + "name": "shoyu", + "version": "1.0.0", + "description": "ShoyuNFT.", + "main": "contracts/Shoyu.sol", + "author": "0xMasayoshi", + "license": "MIT", + "private": false, + "engines": { + "node": ">=16.0.0" + }, + "dependencies": { + "@nomiclabs/hardhat-etherscan": "^3.1.0", + "@openzeppelin/contracts": "^4.7.0", + "@openzeppelin/contracts-upgradeable": "^4.7.0", + "@openzeppelin/hardhat-upgrades": "^1.19.0", + "@sushiswap/core": "^1.4.2", + "@sushiswap/core-sdk": "^1.0.0-canary.34", + "@tenderly/hardhat-tenderly": "^1.0.15", + "@types/readline-sync": "^1.4.4", + "ethers": "^5.6.8", + "ethers-eip712": "^0.2.0", + "hardhat": "https://github.com/0age/hardhat/releases/download/viaIR-2.9.3/hardhat-v2.9.3.tgz", + "hardhat-deploy-ethers": "^0.3.0-beta.13", + "readline-sync": "^1.4.10" + }, + "devDependencies": { + "seaport": "git+https://github.com/ProjectOpenSea/seaport.git#5c6a628cb152d731e956682dd748d30e8bf1f1c9", + "@nomiclabs/hardhat-ethers": "npm:hardhat-deploy-ethers", + "@nomiclabs/hardhat-waffle": "^2.0.1", + "@rari-capital/solmate": "^6.2.0", + "@typechain/ethers-v5": "^10.0.0", + "@typechain/hardhat": "^6.0.0", + "@types/chai": "^4.3.0", + "@types/mocha": "^9.0.0", + "@types/node": "^17.0.8", + "@typescript-eslint/eslint-plugin": "^5.9.1", + "@typescript-eslint/parser": "^5.9.1", + "chai": "^4.3.6", + "dotenv": "^16.0.0", + "eslint": "^8.6.0", + "eslint-config-prettier": "^8.3.0", + "eslint-config-standard": "^17.0.0", + "eslint-plugin-import": "^2.25.4", + "eslint-plugin-n": "^15.2.0", + "eslint-plugin-prettier": "^4.0.0", + "eslint-plugin-promise": "^6.0.0", + "ethereum-waffle": "^3.4.4", + "hardhat-deploy": "^0.11.10", + "hardhat-gas-reporter": "^1.0.7", + "husky": ">=6", + "lint-staged": ">=10", + "prettier": "^2.5.1", + "prettier-plugin-solidity": "^1.0.0-beta.19", + "scuffed-abi": "^1.0.4", + "solhint": "^3.3.6", + "solidity-coverage": "^0.7.0", + "ts-node": "^10.4.0", + "typechain": "^8.0.0", + "typescript": "^4.5.4" + }, + "resolutions": { + "async": ">=2.6.4", + "cross-fetch": ">=3.1.5", + "lodash": ">=4.17.21", + "node-fetch": ">=2.6.7", + "underscore": ">=1.12.1", + "yargs-parser": ">=5.0.1" + }, + "scripts": { + "build": "hardhat compile --config ./hardhat.config.ts", + "test": "hardhat test --config ./hardhat.config.ts", + "profile": "REPORT_GAS=true hardhat test --config ./hardhat.config.ts", + "coverage": "hardhat coverage --config ./hardhat-coverage.config.ts --solcoverjs ./config/.solcover.js", + "lint:check": "prettier --check **.sol && prettier --check **.js && prettier --check **.ts && hardhat compile --config ./hardhat.config.ts && npx solhint --config ./config/.solhint.json --ignore-path ./config/.solhintignore 'contracts/**/*.sol'", + "lint:fix": "prettier --write **.sol && prettier --write **.js && prettier --write **.ts", + "prepare": "husky install", + "goerli:deploy": "hardhat --network goerli deploy", + "goerli:verify": "hardhat --network goerli etherscan-verify --license MIT", + "goerli:export": "hardhat --network goerli export --export exports/goerli.json" + }, + "lint-staged": { + "*.sol": "prettier --write", + "*.js": "prettier --write", + "*.ts": "prettier --write" + }, + "prettier": { + "overrides": [ + { + "files": "*.sol", + "options": { + "tabWidth": 4, + "printWidth": 80, + "bracketSpacing": true + } + } + ] + }, + "eslintConfig": { + "env": { + "browser": false, + "es2021": true, + "mocha": true, + "node": true + }, + "plugins": [ + "@typescript-eslint", + "import" + ], + "extends": [ + "standard", + "plugin:prettier/recommended", + "eslint:recommended", + "plugin:import/recommended", + "plugin:import/typescript" + ], + "parser": "@typescript-eslint/parser", + "parserOptions": { + "ecmaVersion": 12 + }, + "rules": { + "node/no-unsupported-features/es-syntax": [ + "error", + { + "ignores": [ + "modules" + ] + } + ] + } + }, + "eslintIgnore": [ + "node_modules", + "artifacts", + "cache", + "coverage" + ] +} diff --git a/remappings.txt b/remappings.txt new file mode 100644 index 00000000..6977d49f --- /dev/null +++ b/remappings.txt @@ -0,0 +1,4 @@ +murky/=./lib/murky/src/ +ds-test/=./lib/ds-test/src/ +solmate/=./lib/solmate/src/ +@rari-capital/solmate=./lib/solmate/ \ No newline at end of file diff --git a/scripts/conduit.ts b/scripts/conduit.ts new file mode 100644 index 00000000..6b61f805 --- /dev/null +++ b/scripts/conduit.ts @@ -0,0 +1,47 @@ +import hre, { ethers } from "hardhat"; +import readlineSync from "readline-sync"; + +import { CONDUIT_CONTROLLER_ADDRESS } from "../constants/addresses"; + +async function main() { + const { deployer } = await ethers.getNamedSigners(); + + const { chainId } = await ethers.provider.getNetwork(); + + const conduitController = await ethers.getContractAt( + "ConduitController", + CONDUIT_CONTROLLER_ADDRESS[chainId] + ); + + const keyNonce = readlineSync.question("Conduit key nonce: "); + + const conduitKey = `${deployer.address}${ + keyNonce.length < 24 + ? String(keyNonce).padStart(24, "0") + : keyNonce.slice(0, 24) + }`; + + let { gasLimit } = await ethers.provider.getBlock("latest"); + if ((hre as any).__SOLIDITY_COVERAGE_RUNNING) { + gasLimit = ethers.BigNumber.from(300_000_000); + } + + console.log("Creating conduit"); + await conduitController + .connect(deployer) + .createConduit(conduitKey, deployer.address, { gasLimit }); + + const { conduit: conduitAddress, exists } = + await conduitController.getConduit(conduitKey); + + console.log("Created conduit"); + console.log("\t- address", conduitAddress); + console.log("\t- key", conduitKey); +} + +main() + .then(() => process.exit(0)) + .catch((error) => { + console.error(error); + process.exit(1); + }); diff --git a/test/index.test.ts b/test/index.test.ts new file mode 100644 index 00000000..a1e3a209 --- /dev/null +++ b/test/index.test.ts @@ -0,0 +1,2414 @@ +import { BigNumber, constants, Contract, Wallet } from "ethers"; +import { deployments, ethers, network } from "hardhat"; +import { MaxUint256, AddressZero } from "@ethersproject/constants"; +import { expect } from "chai"; +import { + defaultAbiCoder, + Interface, + parseEther, + splitSignature, +} from "ethers/lib/utils"; + +import IUNISWAPV2_ABI from "@sushiswap/core/build/abi/IUniswapV2Pair.json"; + +import { seedSushiswapPools } from "./utils/fixtures/seedSushiswapPools"; +import { faucet } from "./utils/impersonate"; +import { seaportFixture } from "./utils/fixtures"; +import { + defaultBuyNowMirrorFulfillment, + getItem721, + getItemETH, + randomHex, + toFulfillmentComponents, + toKey, +} from "./utils/encoding"; +import { deployContract } from "./utils/contracts"; +import { shoyuFixture } from "./utils/fixtures/shoyuFixture"; +import { + ACTION_LEGACY_SWAP_EXACT_OUT, + ACTION_SEAPORT_FULFILLMENT, + TokenSource, +} from "./utils/contsants"; +import { signBentoMasterContractApproval } from "./utils/helpers"; + +describe(`Shoyu exchange test suite`, function () { + const provider = ethers.provider; + let shoyuContract: Contract; + let transformationAdapter: Contract; + let seaportAdapter: Contract; + let bentobox: Contract; + let zone: Wallet; + let marketplaceContract: Contract; + let testERC20: Contract; + let testERC721: Contract; + let testERC1155: Contract; + let testERC1155Two: Contract; + let testWETH: Contract; + let owner: Wallet; + let withBalanceChecks: any; + let EIP1271WalletFactory: any; + let reenterer; + let stubZone: any; + let conduitController: any; + let conduitImplementation; + let conduitOne: any; + let conduitKeyOne: any; + let directMarketplaceContract: Contract; + let mintAndApproveERC20: any; + let getTestItem20: any; + let set721ApprovalForAll; + let mint721; + let mint721s; + let mintAndApprove721: any; + let getTestItem721: any; + let getTestItem721WithCriteria; + let mintAndApprove1155: any; + let getTestItem1155WithCriteria; + let getTestItem1155: any; + let deployNewConduit: any; + let createTransferWithApproval; + let createOrder: any; + let createMirrorBuyNowOrder: any; + let createMirrorAcceptOfferOrder; + let checkExpectedEvents: any; + + const simulateMatchOrders = async ( + orders: any, + fulfillments: any, + caller: Wallet, + value: BigNumber + ) => { + return marketplaceContract + .connect(caller) + .callStatic.matchOrders(orders, fulfillments, { + value, + }); + }; + + after(async () => { + await network.provider.request({ + method: "hardhat_reset", + }); + }); + + before(async () => { + owner = new ethers.Wallet(randomHex(32), provider); + + await Promise.all( + [owner].map((wallet) => faucet(wallet.address, provider)) + ); + + ({ + EIP1271WalletFactory, + reenterer, + conduitController, + conduitImplementation, + conduitKeyOne, + conduitOne, + deployNewConduit, + testERC20, + mintAndApproveERC20, + getTestItem20, + testERC721, + set721ApprovalForAll, + mint721, + mint721s, + mintAndApprove721, + getTestItem721, + getTestItem721WithCriteria, + testERC1155, + mintAndApprove1155, + directMarketplaceContract, + getTestItem1155WithCriteria, + getTestItem1155, + testERC1155Two, + createTransferWithApproval, + marketplaceContract, + stubZone, + createOrder, + createMirrorBuyNowOrder, + createMirrorAcceptOfferOrder, + withBalanceChecks, + checkExpectedEvents, + } = await seaportFixture(owner)); + + ({ + shoyuContract, + testWETH, + transformationAdapter, + seaportAdapter, + bentobox, + } = await shoyuFixture(owner, marketplaceContract, conduitController)); + }); + + describe("Shoyu tests", async () => { + let seller: Wallet; + let sellerContract; + let buyerContract; + let buyer: Wallet; + + before(async () => { + // Setup basic buyer/seller wallets with ETH + seller = new ethers.Wallet(randomHex(32), provider); + buyer = new ethers.Wallet(randomHex(32), provider); + zone = new ethers.Wallet(randomHex(32), provider); + + sellerContract = await EIP1271WalletFactory.deploy(seller.address); + buyerContract = await EIP1271WalletFactory.deploy(buyer.address); + + await Promise.all( + [seller, buyer, zone, sellerContract, buyerContract].map((wallet) => + faucet(wallet.address, provider) + ) + ); + }); + + describe("[SEAPORT] Tests basic order fulfillment", async () => { + beforeEach(async () => { + await Promise.all( + [seller, buyer].map((wallet) => faucet(wallet.address, provider)) + ); + }); + + it("Buyer purchases listed ERC721 via fulfillOrder()", async () => { + // seller creates listing for 1ERC721 at price of 1ETH + .1ETH fee + const nftId = await mintAndApprove721( + seller, + marketplaceContract.address + ); + + const offer = [getTestItem721(nftId)]; + + const consideration = [ + getItemETH(parseEther("1"), parseEther("1"), seller.address), + getItemETH(parseEther(".1"), parseEther(".1"), zone.address), + ]; + + const { order, orderHash, value } = await createOrder( + seller, + zone, + offer, + consideration, + 0 // FULL_OPEN + ); + + // buyer fills order through Shoyu contract + // and swaps ERC20 for ETH before filling the order + await withBalanceChecks([order], 0, null, async () => { + const tx = marketplaceContract + .connect(buyer) + .fulfillOrder(order, toKey(false), { + value, + }); + const receipt = await (await tx).wait(); + await checkExpectedEvents(tx, receipt, [ + { + order, + orderHash, + fulfiller: buyer.address, + }, + ]); + return receipt; + }); + }); + + it("Buyer purchases listed ERC721 via fulfillOrder() with tip", async () => { + // seller creates listing for 1ERC721 at price of 1ETH + .1ETH fee + const nftId = await mintAndApprove721( + seller, + marketplaceContract.address + ); + + const offer = [getTestItem721(nftId)]; + + const consideration = [ + getItemETH(parseEther("1"), parseEther("1"), seller.address), + getItemETH(parseEther(".1"), parseEther(".1"), zone.address), + ]; + + const { order, orderHash, value } = await createOrder( + seller, + zone, + offer, + consideration, + 0 // FULL_OPEN + ); + + order.parameters.consideration.push( + getItemETH(parseEther(".5"), parseEther(".5"), seller.address) + ); + + const totalValue = value.add(parseEther(".5")); + + // buyer fills order through Shoyu contract + // and swaps ERC20 for ETH before filling the order + await withBalanceChecks([order], 0, null, async () => { + const tx = marketplaceContract + .connect(buyer) + .fulfillOrder(order, toKey(false), { + value: totalValue, + }); + const receipt = await (await tx).wait(); + await checkExpectedEvents(tx, receipt, [ + { + order, + orderHash, + fulfiller: buyer.address, + }, + ]); + return receipt; + }); + }); + + it("Buyer purchases listed ERC721 via fulfillAdvancedOrder()", async () => { + const nftId = await mintAndApprove721( + seller, + marketplaceContract.address + ); + + const offer = [getTestItem721(nftId)]; + + const consideration = [ + getItemETH(parseEther("10"), parseEther("10"), seller.address), + getItemETH(parseEther("1"), parseEther("1"), zone.address), + getItemETH(parseEther("1"), parseEther("1"), owner.address), + ]; + + const { order, orderHash, value } = await createOrder( + seller, + stubZone, + offer, + consideration, + 2 // FULL_RESTRICTED + ); + + order.extraData = "0x1234"; + + await withBalanceChecks([order], 0, null, async () => { + const tx = marketplaceContract + .connect(buyer) + .fulfillAdvancedOrder( + order, + [], + toKey(false), + constants.AddressZero, + { + value, + } + ); + const receipt = await (await tx).wait(); + await checkExpectedEvents(tx, receipt, [ + { + order, + orderHash, + fulfiller: buyer.address, + }, + ]); + + return receipt; + }); + }); + + it("Orders with different zones can be matched and filled via matchOrders()", async () => { + const stubZone2 = await deployContract("TestZone", seller as any); + + const nftId = await mintAndApprove721( + seller, + marketplaceContract.address + ); + + const offer = [getTestItem721(nftId)]; + + const consideration = [ + getItemETH(parseEther("1"), parseEther("1"), seller.address), + getItemETH(parseEther(".1"), parseEther(".1"), zone.address), + getItemETH(parseEther(".1"), parseEther(".1"), owner.address), + ]; + + const { order, orderHash, value } = await createOrder( + seller, + stubZone, + offer, + consideration, + 2 // FULL_OPEN + ); + + const { mirrorOrder, mirrorOrderHash } = await createMirrorBuyNowOrder( + buyer, + stubZone2, + order + ); + + const fulfillments = defaultBuyNowMirrorFulfillment; + + const executions = await simulateMatchOrders( + [order, mirrorOrder], + fulfillments, + owner, + value + ); + expect(executions.length).to.equal(4); + + const tx = marketplaceContract + .connect(owner) + .matchOrders([order, mirrorOrder], fulfillments, { + value, + }); + const receipt = await (await tx).wait(); + await checkExpectedEvents( + tx, + receipt, + [ + { + order, + orderHash, + fulfiller: constants.AddressZero, + }, + { + order: mirrorOrder, + orderHash: mirrorOrderHash, + fulfiller: constants.AddressZero, + }, + ], + executions + ); + return receipt; + }); + + it("Buyer pays fees when offer is accepted", async () => { + // buyer creates listing for 1ERC721 at price of 1WETH + .1WETH fee + await mintAndApproveERC20( + buyer, + marketplaceContract.address, + parseEther("2") + ); + + const nftId = await mintAndApprove721( + seller, + marketplaceContract.address + ); + + const offer = [ + getTestItem20(parseEther("1"), parseEther("1")), + getTestItem20(parseEther(".1"), parseEther(".1"), zone.address), + ]; + + const consideration = [getTestItem721(nftId, 1, 1, buyer.address)]; + + const { order, orderHash, value } = await createOrder( + buyer, + zone, + offer, + consideration, + 0 // FULL_OPEN + ); + + // buyer fills order through Shoyu contract + // and swaps ERC20 for ETH before filling the order + await withBalanceChecks([order], 0, null, async () => { + const tx = marketplaceContract + .connect(seller) + .fulfillOrder(order, toKey(false)); + const receipt = await (await tx).wait(); + await checkExpectedEvents(tx, receipt, [ + { + order, + orderHash, + fulfiller: seller.address, + }, + ]); + return receipt; + }); + }); + }); + + describe("[SHOYU] Tests sushiswap integration", async () => { + beforeEach(async () => { + await seedSushiswapPools({ + pairs: [ + { + token0: testWETH, + token0Amount: parseEther("50"), + token1: testERC20, + token1Amount: parseEther("25"), + }, + ], + }); + + await Promise.all( + [seller, buyer].map((wallet) => faucet(wallet.address, provider)) + ); + }); + + it("User buys ERC721 listed in ETH by swapping ERC20 -> ETH", async () => { + // seller creates listing for 1ERC721 at price of 1ETH + .1ETH fee + const nftId = await mintAndApprove721( + seller, + marketplaceContract.address + ); + + const offer = [getTestItem721(nftId)]; + + const consideration = [ + getItemETH(parseEther("1"), parseEther("1"), seller.address), + getItemETH(parseEther(".1"), parseEther(".1"), zone.address), + ]; + + const { order, orderHash, value } = await createOrder( + seller, + zone, + offer, + consideration, + 0 // FULL_OPEN + ); + + // buyer fills order through Shoyu contract + // and swaps ERC20 for ETH before filling the order + await mintAndApproveERC20( + buyer, + shoyuContract.address, + parseEther("5") + ); + + await withBalanceChecks([order], 0, null, async () => { + const tx = shoyuContract.connect(buyer).cook( + [0, 1], + [0, value], + [ + transformationAdapter.interface.encodeFunctionData( + "swapExactOut", + [ + value, // amountOut + MaxUint256, // amountInMax + [testERC20.address, testWETH.address], // path + shoyuContract.address, // to + TokenSource.WALLET, // tokenSource + "0x", // transferData + true, // unwrapNativeToken + ] + ), + seaportAdapter.interface.encodeFunctionData("fulfill", [ + value, + marketplaceContract.interface.encodeFunctionData( + "fulfillAdvancedOrder", + [order, [], toKey(false), buyer.address] + ), + ]), + ] + ); + const receipt = await (await tx).wait(); + + await checkExpectedEvents(tx, receipt, [ + { + order, + orderHash, + fulfiller: buyer.address, + }, + ]); + return receipt; + }); + }); + + it("User buys ERC721 listed in ETH with WETH in bentobox", async () => { + // seller creates listing for 1ERC721 at price of 1ETH + .1ETH fee + const nftId = await mintAndApprove721( + seller, + marketplaceContract.address + ); + + const offer = [getTestItem721(nftId)]; + + const consideration = [ + getItemETH(parseEther("1"), parseEther("1"), seller.address), + getItemETH(parseEther(".1"), parseEther(".1"), zone.address), + ]; + + const { order, orderHash, value } = await createOrder( + seller, + zone, + offer, + consideration, + 0 // FULL_OPEN + ); + + // buyer fills order through Shoyu contract + // by paying with WETH from bentobox + await bentobox + .connect(buyer) + .deposit( + AddressZero, + buyer.address, + buyer.address, + parseEther("2"), + 0, + { + value: parseEther("2"), + } + ); + + const { v, r, s } = await signBentoMasterContractApproval( + bentobox, + buyer, + shoyuContract.address + ); + + await bentobox + .connect(buyer) + .setMasterContractApproval( + buyer.address, + shoyuContract.address, + true, + v, + r, + s + ); + + await withBalanceChecks([order], 0, null, async () => { + const tx = shoyuContract.connect(buyer).cook( + [0, 0, 1], + [0, 0, value], + [ + transformationAdapter.interface.encodeFunctionData( + "transferERC20From", + [ + testWETH.address, // token + shoyuContract.address, // to + value, // amount + TokenSource.BENTO, // tokenSource + toKey(true), // transferData + ] + ), + transformationAdapter.interface.encodeFunctionData( + "unwrapNativeToken", + [ + value, // amount + shoyuContract.address, // to + ] + ), + seaportAdapter.interface.encodeFunctionData("fulfill", [ + value, + marketplaceContract.interface.encodeFunctionData( + "fulfillAdvancedOrder", + [order, [], toKey(false), buyer.address] + ), + ]), + ] + ); + const receipt = await (await tx).wait(); + + await checkExpectedEvents(tx, receipt, [ + { + order, + orderHash, + fulfiller: buyer.address, + }, + ]); + return receipt; + }); + }); + + it("User buys ERC721 listed in ETH by unwrapping WETH -> ETH", async () => { + // seller creates listing for 1ERC721 at price of 1ETH + .1ETH fee + const nftId = await mintAndApprove721( + seller, + marketplaceContract.address + ); + + const offer = [getTestItem721(nftId)]; + + const consideration = [ + getItemETH(parseEther("1"), parseEther("1"), seller.address), + getItemETH(parseEther(".1"), parseEther(".1"), zone.address), + ]; + + const { order, orderHash, value } = await createOrder( + seller, + zone, + offer, + consideration, + 0 // FULL_OPEN + ); + + // buyer fills order through Shoyu contract + // and unwraps WETH for ETH before filling the order + await testWETH.connect(buyer).deposit({ value }); + await testWETH + .connect(buyer) + .approve(shoyuContract.address, MaxUint256); + + await withBalanceChecks([order], 0, null, async () => { + const tx = shoyuContract.connect(buyer).cook( + [0, 0, 1], + [0, 0, value], + [ + transformationAdapter.interface.encodeFunctionData( + "transferERC20From", + [ + testWETH.address, // token + shoyuContract.address, // to + value, // amount + TokenSource.WALLET, // tokenSource + "0x", // transferData + ] + ), + transformationAdapter.interface.encodeFunctionData( + "unwrapNativeToken", + [ + value, // amount + shoyuContract.address, // to + ] + ), + seaportAdapter.interface.encodeFunctionData("fulfill", [ + value, + marketplaceContract.interface.encodeFunctionData( + "fulfillAdvancedOrder", + [order, [], toKey(false), buyer.address] + ), + ]), + ] + ); + const receipt = await (await tx).wait(); + + await checkExpectedEvents(tx, receipt, [ + { + order, + orderHash, + fulfiller: buyer.address, + }, + ]); + return receipt; + }); + }); + + it("User buys ERC721 listed in WETH by wrapping ETH -> WETH", async () => { + // seller creates listing for 1ERC721 at price of 1WETH + .1WETH fee + const nftId = await mintAndApprove721( + seller, + marketplaceContract.address + ); + + const offer = [getTestItem721(nftId)]; + + const consideration = [ + getTestItem20( + parseEther("1"), + parseEther("1"), + seller.address, + testWETH.address + ), + getTestItem20( + parseEther(".1"), + parseEther(".1"), + zone.address, + testWETH.address + ), + ]; + + const { order, orderHash } = await createOrder( + seller, + zone, + offer, + consideration, + 0 // FULL_OPEN + ); + + const value = parseEther("1.1"); + + await withBalanceChecks([order], 0, null, async () => { + const tx = shoyuContract.connect(buyer).cook( + [0, 1], + [0, 0], + [ + transformationAdapter.interface.encodeFunctionData( + "wrapNativeToken", + [ + value, // amount + ] + ), + seaportAdapter.interface.encodeFunctionData("fulfill", [ + toKey(false), + marketplaceContract.interface.encodeFunctionData( + "fulfillAdvancedOrder", + [order, [], toKey(false), buyer.address] + ), + ]), + ], + { + value, + } + ); + const receipt = await (await tx).wait(); + + await checkExpectedEvents( + tx, + receipt, + [ + { + order, + orderHash, + fulfiller: buyer.address, + }, + ], + [ + { + item: { ...consideration[0], amount: parseEther("1") }, + offerer: shoyuContract.address, + conduitKey: toKey(false), + }, + ] + ); + + return receipt; + }); + }); + + it("User buys ERC721 listed in ETH by swapping ERC20 -> ETH (with conduit)", async () => { + await conduitController + .connect(owner) + .updateChannel(conduitOne.address, shoyuContract.address, true); + + // seller creates listing for 1ERC721 at price of 1ETH + .1ETH fee + const nftId = await mintAndApprove721( + seller, + marketplaceContract.address + ); + + const offer = [getTestItem721(nftId)]; + + const consideration = [ + getItemETH(parseEther("1"), parseEther("1"), seller.address), + getItemETH(parseEther(".1"), parseEther(".1"), zone.address), + ]; + + const { order, orderHash, value } = await createOrder( + seller, + zone, + offer, + consideration, + 0 // FULL_OPEN + ); + + // buyer fills order through Shoyu contract + // and swaps ERC20 for ETH before filling the order + await mintAndApproveERC20(buyer, conduitOne.address, parseEther("5")); + + await withBalanceChecks([order], 0, null, async () => { + const tx = shoyuContract.connect(buyer).cook( + [0, 1], + [0, value], + [ + transformationAdapter.interface.encodeFunctionData( + "swapExactOut", + [ + value, // amountOut + MaxUint256, // amountInMax + [testERC20.address, testWETH.address], // path + shoyuContract.address, // to + TokenSource.CONDUIT, // tokenSource + conduitKeyOne, // transferData + true, // unwrapNativeToken + ] + ), + seaportAdapter.interface.encodeFunctionData("fulfill", [ + value, + marketplaceContract.interface.encodeFunctionData( + "fulfillAdvancedOrder", + [order, [], toKey(false), buyer.address] + ), + ]), + ] + ); + const receipt = await (await tx).wait(); + + await checkExpectedEvents(tx, receipt, [ + { + order, + orderHash, + fulfiller: buyer.address, + }, + ]); + return receipt; + }); + }); + + it("User buys single listed bundle of ERC721+ERC1155 by swapping ERC20 -> ETH", async () => { + // seller creates listing for 1ERC721 + 1ERC1155 at price of 1ETH + .1ETH fee + const erc721Id = await mintAndApprove721( + seller, + marketplaceContract.address + ); + + const { nftId: erc1155Id, amount: erc1155Amount } = + await mintAndApprove1155(seller, marketplaceContract.address, 1); + + const offer = [ + getTestItem721(erc721Id), + getTestItem1155(erc1155Id, erc1155Amount, erc1155Amount), + ]; + + const consideration = [ + getItemETH(parseEther("1"), parseEther("1"), seller.address), + getItemETH(parseEther(".1"), parseEther(".1"), zone.address), + ]; + + const { order, orderHash, value } = await createOrder( + seller, + zone, + offer, + consideration, + 0 // FULL_OPEN + ); + + // buyer fills order through Shoyu contract + // and swaps ERC20 for ETH before filling the order + await mintAndApproveERC20( + buyer, + shoyuContract.address, + parseEther("5") + ); + + await withBalanceChecks([order], 0, null, async () => { + const tx = shoyuContract.connect(buyer).cook( + [0, 1], + [0, value], + [ + transformationAdapter.interface.encodeFunctionData( + "swapExactOut", + [ + value, // amountOut + MaxUint256, // amountInMax + [testERC20.address, testWETH.address], // path + shoyuContract.address, // to + TokenSource.WALLET, // tokenSource + "0x", // transferData + true, // unwrapNativeToken + ] + ), + seaportAdapter.interface.encodeFunctionData("fulfill", [ + value, + marketplaceContract.interface.encodeFunctionData( + "fulfillAdvancedOrder", + [order, [], toKey(false), buyer.address] + ), + ]), + ] + ); + const receipt = await (await tx).wait(); + + await checkExpectedEvents(tx, receipt, [ + { + order, + orderHash, + fulfiller: buyer.address, + }, + ]); + return receipt; + }); + }); + + it("User buys listed ERC721 with ETH and swapping ERC20 -> ETH", async () => { + // seller creates listing for 1ERC721 at price of 1ETH + .1ETH fee + const nftId = await mintAndApprove721( + seller, + marketplaceContract.address + ); + + const offer = [getTestItem721(nftId)]; + + const consideration = [ + getItemETH(parseEther("1"), parseEther("1"), seller.address), + getItemETH(parseEther(".1"), parseEther(".1"), zone.address), + ]; + + const { order, orderHash, value } = await createOrder( + seller, + zone, + offer, + consideration, + 0 // FULL_OPEN + ); + + // buyer fills order through Shoyu contract + // and swaps ERC20 for ETH before filling the order + await mintAndApproveERC20( + buyer, + shoyuContract.address, + parseEther("5") + ); + + await withBalanceChecks([order], 0, null, async () => { + const tx = shoyuContract.connect(buyer).cook( + [0, 1], + [0, value], + [ + transformationAdapter.interface.encodeFunctionData( + "swapExactOut", + [ + value.div(2), // amountOut + MaxUint256, // amountInMax + [testERC20.address, testWETH.address], // path + shoyuContract.address, // to + TokenSource.WALLET, // tokenSource + "0x", // transferData + true, // unwrapNativeToken + ] + ), + seaportAdapter.interface.encodeFunctionData("fulfill", [ + value, + marketplaceContract.interface.encodeFunctionData( + "fulfillAdvancedOrder", + [order, [], toKey(false), buyer.address] + ), + ]), + ], + { + value: value.div(2), + } + ); + const receipt = await (await tx).wait(); + + await checkExpectedEvents(tx, receipt, [ + { + order, + orderHash, + fulfiller: buyer.address, + }, + ]); + return receipt; + }); + }); + + it("User batch buys ERC721+ERC1155 in seperate listings by swapping ERC20 -> ETH", async () => { + // seller creates listing for 1ERC721 + 1ERC1155 at price of 1ETH + .1ETH fee + const erc721Id = await mintAndApprove721( + seller, + marketplaceContract.address + ); + + const { nftId: erc1155Id, amount: erc1155Amount } = + await mintAndApprove1155(seller, marketplaceContract.address, 1); + + // order0: 1 ERC721 for 1ETH+.1ETH Fee + const offer0 = [getTestItem721(erc721Id)]; + + const consideration0 = [ + getItemETH(parseEther("1"), parseEther("1"), seller.address), + getItemETH(parseEther(".1"), parseEther(".1"), zone.address), + ]; + + const { + order: order0, + orderHash: orderHash0, + value: value0, + } = await createOrder( + seller, + zone, + offer0, + consideration0, + 0 // FULL_OPEN + ); + + // order1: 1 ERC1155 for 1ETH+.1ETH Fee + const offer1 = [ + getTestItem1155(erc1155Id, erc1155Amount, erc1155Amount), + ]; + + const consideration1 = [ + getItemETH(parseEther("1"), parseEther("1"), seller.address), + getItemETH(parseEther(".1"), parseEther(".1"), zone.address), + ]; + + const { + order: order1, + orderHash: orderHash1, + value: value1, + } = await createOrder( + seller, + zone, + offer1, + consideration1, + 0 // FULL_OPEN + ); + + // buyer fills order through Shoyu contract + // and swaps ERC20 for ETH before filling the order + await mintAndApproveERC20( + buyer, + shoyuContract.address, + parseEther("5") + ); + + const offerComponents = [[[0, 0]], [[1, 0]]].map( + toFulfillmentComponents + ); + + const considerationComponents = [ + [ + [0, 0], + [1, 0], + ], + [ + [0, 1], + [1, 1], + ], + ].map(toFulfillmentComponents); + + const totalValue = value0.add(value1); + + await withBalanceChecks([order0, order1], 0, null, async () => { + const tx = shoyuContract.connect(buyer).cook( + [0, 1], + [0, totalValue], + [ + transformationAdapter.interface.encodeFunctionData( + "swapExactOut", + [ + totalValue, // amountOut + MaxUint256, // amountInMax + [testERC20.address, testWETH.address], // path + shoyuContract.address, // to + TokenSource.WALLET, // tokenSource + "0x", // transferData + true, // unwrapNativeToken + ] + ), + seaportAdapter.interface.encodeFunctionData("fulfill", [ + totalValue, + marketplaceContract.interface.encodeFunctionData( + "fulfillAvailableAdvancedOrders", + [ + [order0, order1], + [], + offerComponents, + considerationComponents, + toKey(false), + buyer.address, + 2, + ] + ), + ]), + ] + ); + + const receipt = await (await tx).wait(); + + await checkExpectedEvents(tx, receipt, [ + { + order: order0, + orderHash: orderHash0, + fulfiller: buyer.address, + receipt: buyer.address, + }, + { + order: order1, + orderHash: orderHash1, + fulfiller: buyer.address, + receipt: buyer.address, + }, + ]); + return receipt; + }); + }); + + it("User batch buys ERC721+ERC1155 in seperate listings with ETH and swapping ERC20 -> ETH", async () => { + // seller creates listing for 1ERC721 + 1ERC1155 at price of 1ETH + .1ETH fee + const erc721Id = await mintAndApprove721( + seller, + marketplaceContract.address + ); + + const { nftId: erc1155Id, amount: erc1155Amount } = + await mintAndApprove1155(seller, marketplaceContract.address, 1); + + // order0: 1 ERC721 for 1ETH+.1ETH Fee + const offer0 = [getTestItem721(erc721Id)]; + + const consideration0 = [ + getItemETH(parseEther("1"), parseEther("1"), seller.address), + getItemETH(parseEther(".1"), parseEther(".1"), zone.address), + ]; + + const { + order: order0, + orderHash: orderHash0, + value: value0, + } = await createOrder( + seller, + zone, + offer0, + consideration0, + 0 // FULL_OPEN + ); + + // order1: 1 ERC1155 for 1ETH+.1ETH Fee + const offer1 = [ + getTestItem1155(erc1155Id, erc1155Amount, erc1155Amount), + ]; + + const consideration1 = [ + getItemETH(parseEther("1"), parseEther("1"), seller.address), + getItemETH(parseEther(".1"), parseEther(".1"), zone.address), + ]; + + const { + order: order1, + orderHash: orderHash1, + value: value1, + } = await createOrder( + seller, + zone, + offer1, + consideration1, + 0 // FULL_OPEN + ); + + // buyer fills order through Shoyu contract + // and swaps ERC20 for ETH before filling the order + await mintAndApproveERC20( + buyer, + shoyuContract.address, + parseEther("5") + ); + + const offerComponents = [[[0, 0]], [[1, 0]]].map( + toFulfillmentComponents + ); + + const considerationComponents = [ + [ + [0, 0], + [1, 0], + ], + [ + [0, 1], + [1, 1], + ], + ].map(toFulfillmentComponents); + + const totalValue = value0.add(value1); + + await withBalanceChecks([order0, order1], 0, null, async () => { + const tx = shoyuContract.connect(buyer).cook( + [0, 1], + [0, totalValue], + [ + transformationAdapter.interface.encodeFunctionData( + "swapExactOut", + [ + totalValue.div(2), // amountOut + MaxUint256, // amountInMax + [testERC20.address, testWETH.address], // path + shoyuContract.address, // to + TokenSource.WALLET, // tokenSource + "0x", // transferData + true, // unwrapNativeToken + ] + ), + seaportAdapter.interface.encodeFunctionData("fulfill", [ + totalValue, + marketplaceContract.interface.encodeFunctionData( + "fulfillAvailableAdvancedOrders", + [ + [order0, order1], + [], + offerComponents, + considerationComponents, + toKey(false), + buyer.address, + 2, + ] + ), + ]), + ], + { + value: totalValue.div(2), + } + ); + + const receipt = await (await tx).wait(); + + await checkExpectedEvents(tx, receipt, [ + { + order: order0, + orderHash: orderHash0, + fulfiller: buyer.address, + receipt: buyer.address, + }, + { + order: order1, + orderHash: orderHash1, + fulfiller: buyer.address, + receipt: buyer.address, + }, + ]); + return receipt; + }); + }); + + it("Excess ETH is refunded when buying listed ERC721 by swapping ERC20 -> ETH", async () => { + // seller creates listing for 1ERC721 at price of 1ETH + .1ETH fee + const nftId = await mintAndApprove721( + seller, + marketplaceContract.address + ); + + const offer = [getTestItem721(nftId)]; + + const consideration = [ + getItemETH(parseEther("1"), parseEther("1"), seller.address), + getItemETH(parseEther(".1"), parseEther(".1"), zone.address), + ]; + + const { order, orderHash, value } = await createOrder( + seller, + zone, + offer, + consideration, + 0 // FULL_OPEN + ); + + // buyer fills order through Shoyu contract + // and swaps ERC20 for ETH before filling the order + await mintAndApproveERC20( + buyer, + shoyuContract.address, + parseEther("5") + ); + + const buyerETHBalanceBefore = await provider.getBalance(buyer.address); + + await withBalanceChecks([order], 0, null, async () => { + const tx = shoyuContract.connect(buyer).cook( + [0, 1], + [0, value], + [ + transformationAdapter.interface.encodeFunctionData( + "swapExactOut", + [ + value.add(42069), // amountOut + MaxUint256, // amountInMax + [testERC20.address, testWETH.address], // path + shoyuContract.address, // to + TokenSource.WALLET, // tokenSource + "0x", // transferData + true, // unwrapNativeToken + ] + ), + seaportAdapter.interface.encodeFunctionData("fulfill", [ + value, + marketplaceContract.interface.encodeFunctionData( + "fulfillAdvancedOrder", + [order, [], toKey(false), buyer.address] + ), + ]), + ] + ); + + const receipt = await (await tx).wait(); + + const buyerETHBalanceAfter = await provider.getBalance(buyer.address); + + expect( + buyerETHBalanceAfter.sub(buyerETHBalanceBefore).abs().toString() + ).to.eq( + receipt.effectiveGasPrice.mul(receipt.gasUsed).sub(42069).toString() + ); + + await checkExpectedEvents(tx, receipt, [ + { + order, + orderHash, + fulfiller: buyer.address, + }, + ]); + return receipt; + }); + }); + + it("Excess ETH is refunded if one or more orders cannot be filled when batch filling", async () => { + // seller creates listing for 1ERC721 at price of 1ETH + .1ETH fee + const { amount, nftId } = await mintAndApprove1155( + seller, + marketplaceContract.address + ); + + const offer = [getTestItem1155(nftId, amount.div(2), amount.div(2))]; + + const consideration = [ + getItemETH(parseEther("1"), parseEther("1"), seller.address), + getItemETH(parseEther(".1"), parseEther(".1"), zone.address), + ]; + + const order0 = await createOrder( + seller, + zone, + offer, + consideration, + 0 // FULL_OPEN + ); + + const order1 = await createOrder( + seller, + zone, + offer, + consideration, + 0, // FULL_OPEN + [], + "EXPIRED" + ); + + // buyer fills order through Shoyu contract + // and swaps ERC20 for ETH before filling the order + await mintAndApproveERC20( + buyer, + shoyuContract.address, + parseEther("5") + ); + + const buyerETHBalanceBefore = await provider.getBalance(buyer.address); + const offerComponents = [[[0, 0]], [[1, 0]]].map( + toFulfillmentComponents + ); + + const considerationComponents = [ + [ + [0, 0], + [1, 0], + ], + [ + [0, 1], + [1, 1], + ], + ].map(toFulfillmentComponents); + + const totalValue = order0.value.add(order1.value); + + await withBalanceChecks([order0.order], 0, null, async () => { + const tx = await shoyuContract.connect(buyer).cook( + [0, 1], + [0, totalValue], + [ + transformationAdapter.interface.encodeFunctionData( + "swapExactOut", + [ + totalValue, // amountOut + MaxUint256, // amountInMax + [testERC20.address, testWETH.address], // path + shoyuContract.address, // to + TokenSource.WALLET, // tokenSource + "0x", // transferData + true, // unwrapNativeToken + ] + ), + seaportAdapter.interface.encodeFunctionData("fulfill", [ + totalValue, + marketplaceContract.interface.encodeFunctionData( + "fulfillAvailableAdvancedOrders", + [ + [order0.order, order1.order], + [], + offerComponents, + considerationComponents, + toKey(false), + buyer.address, + 2, + ] + ), + ]), + ] + ); + + const receipt = await (await tx).wait(); + + const lpInterface = new Interface(IUNISWAPV2_ABI); + + const swapEvent = receipt.events + .filter((event: any) => { + try { + lpInterface.decodeEventLog("Swap", event.data, event.topics); + return true; + } catch (e) { + return false; + } + }) + .map((event: any) => + lpInterface.decodeEventLog("Swap", event.data, event.topics) + )[0]; + + const buyerETHBalanceAfter = await provider.getBalance(buyer.address); + + expect( + buyerETHBalanceAfter.sub(buyerETHBalanceBefore).abs().toString() + ).to.eq( + receipt.effectiveGasPrice + .mul(receipt.gasUsed) + .sub(swapEvent.amount0Out) + .add(order1.value) + .abs() + .toString() + ); + + await checkExpectedEvents(tx, receipt, [ + { + order: order0.order, + orderHash: order0.orderHash, + fulfiller: buyer.address, + }, + ]); + return receipt; + }); + }); + + it("User accepts offer on ERC721 and swaps ERC20 -> ETH", async () => { + const nftId = await mintAndApprove721(seller, shoyuContract.address); + + await mintAndApproveERC20( + buyer, + marketplaceContract.address, + parseEther("5") + ); + + // buyer creates offer for 1ERC721 at price of 1ERC20 + .1ERC20 fee + const offer = [ + getTestItem20(parseEther("1"), parseEther("1")), + getTestItem20(parseEther(".1"), parseEther(".1"), zone.address), + ]; + + const consideration = [getTestItem721(nftId, 1, 1, buyer.address)]; + + const { order, orderHash } = await createOrder( + buyer, + zone, + offer, + consideration, + 0 // FULL_OPEN + ); + + // buyer fills order through Shoyu contract + // and swaps ERC20 for ETH before filling the order + const sellerETHBalanceBefore = await provider.getBalance( + seller.address + ); + + await withBalanceChecks([order], 0, null, async () => { + const tx = shoyuContract.connect(seller).cook( + [0, 1, 0], + [0, 0, 0], + [ + transformationAdapter.interface.encodeFunctionData( + "transferERC721From", + [ + testERC721.address, + shoyuContract.address, + nftId, + TokenSource.WALLET, + "0x", + ] + ), + seaportAdapter.interface.encodeFunctionData( + "approveBeforeFulfill", + [ + [testERC721.address], + 0, + marketplaceContract.interface.encodeFunctionData( + "fulfillAdvancedOrder", + [order, [], toKey(false), shoyuContract.address] + ), + ] + ), + transformationAdapter.interface.encodeFunctionData( + "swapExactIn", + [ + parseEther("1"), // amountIn + BigNumber.from(0), // amountOutMin + [testERC20.address, testWETH.address], // path + seller.address, // to + true, // unwrapNativeToken + ] + ), + ] + ); + + const receipt = await (await tx).wait(); + + const lpInterface = new Interface(IUNISWAPV2_ABI); + + const swapEvent = receipt.events + .filter((event: any) => { + try { + lpInterface.decodeEventLog("Swap", event.data, event.topics); + return true; + } catch (e) { + return false; + } + }) + .map((event: any) => + lpInterface.decodeEventLog("Swap", event.data, event.topics) + )[0]; + + const sellerETHBalanceAfter = await provider.getBalance( + seller.address + ); + + expect( + sellerETHBalanceAfter.sub(sellerETHBalanceBefore).abs().toString() + ).to.eq( + receipt.effectiveGasPrice + .mul(receipt.gasUsed) + .sub(swapEvent.amount0Out) + .abs() + .toString() + ); + + await checkExpectedEvents( + tx, + receipt, + [ + { + order, + orderHash, + fulfiller: shoyuContract.address, + }, + ], + [ + { + item: consideration[0], + offerer: shoyuContract.address, + conduitKey: toKey(false), + }, + ] + ); + + return receipt; + }); + }); + + it("User accepts offer on ERC1155 and swaps ERC20 -> ETH", async () => { + const { nftId, amount } = await mintAndApprove1155( + seller, + shoyuContract.address + ); + + await mintAndApproveERC20( + buyer, + marketplaceContract.address, + parseEther("5") + ); + + // buyer creates offer for 1ERC721 at price of 1ERC20 + .1ERC20 fee + const offer = [ + getTestItem20(parseEther("1"), parseEther("1")), + getTestItem20(parseEther(".1"), parseEther(".1"), zone.address), + ]; + + const consideration = [ + getTestItem1155(nftId, amount, amount, undefined, buyer.address), + ]; + + const { order, orderHash } = await createOrder( + buyer, + zone, + offer, + consideration, + 0 // FULL_OPEN + ); + + // buyer fills order through Shoyu contract + // and swaps ERC20 for ETH before filling the order + const sellerETHBalanceBefore = await provider.getBalance( + seller.address + ); + + await withBalanceChecks([order], 0, null, async () => { + const tx = shoyuContract.connect(seller).cook( + [0, 1, 0], + [0, 0, 0], + [ + transformationAdapter.interface.encodeFunctionData( + "transferERC1155From", + [ + testERC1155.address, + shoyuContract.address, + nftId, + amount, + TokenSource.WALLET, + "0x", + ] + ), + seaportAdapter.interface.encodeFunctionData( + "approveBeforeFulfill", + [ + [testERC1155.address], + 0, + marketplaceContract.interface.encodeFunctionData( + "fulfillAdvancedOrder", + [order, [], toKey(false), shoyuContract.address] + ), + ] + ), + transformationAdapter.interface.encodeFunctionData( + "swapExactIn", + [ + parseEther("1"), // amountIn + BigNumber.from(0), // amountOutMin + [testERC20.address, testWETH.address], // path + seller.address, // to + true, // unwrapNativeToken + ] + ), + ] + ); + + const receipt = await (await tx).wait(); + + const lpInterface = new Interface(IUNISWAPV2_ABI); + + const swapEvent = receipt.events + .filter((event: any) => { + try { + lpInterface.decodeEventLog("Swap", event.data, event.topics); + return true; + } catch (e) { + return false; + } + }) + .map((event: any) => + lpInterface.decodeEventLog("Swap", event.data, event.topics) + )[0]; + + const sellerETHBalanceAfter = await provider.getBalance( + seller.address + ); + + expect( + sellerETHBalanceAfter.sub(sellerETHBalanceBefore).abs().toString() + ).to.eq( + receipt.effectiveGasPrice + .mul(receipt.gasUsed) + .sub(swapEvent.amount0Out) + .abs() + .toString() + ); + + await checkExpectedEvents( + tx, + receipt, + [ + { + order, + orderHash, + fulfiller: shoyuContract.address, + }, + ], + [ + { + item: { ...consideration[0], amount }, + offerer: shoyuContract.address, + conduitKey: toKey(false), + operator: marketplaceContract.address, + }, + ] + ); + + return receipt; + }); + }); + + it("User accepts offer on ERC721 for WETH and unwraps to ETH", async () => { + const nftId = await mintAndApprove721(seller, shoyuContract.address); + + await testWETH.connect(buyer).deposit({ value: parseEther("2") }); + await testWETH + .connect(buyer) + .approve(marketplaceContract.address, MaxUint256); + + // buyer creates offer for 1ERC721 at price of 1ERC20 + .1ERC20 fee + const offer = [ + getTestItem20( + parseEther("1"), + parseEther("1"), + undefined, + testWETH.address + ), + getTestItem20( + parseEther(".1"), + parseEther(".1"), + zone.address, + testWETH.address + ), + ]; + + const consideration = [getTestItem721(nftId, 1, 1, buyer.address)]; + + const { order, orderHash } = await createOrder( + buyer, + zone, + offer, + consideration, + 0 // FULL_OPEN + ); + + // buyer fills order through Shoyu contract + // and swaps ERC20 for ETH before filling the order + const sellerETHBalanceBefore = await provider.getBalance( + seller.address + ); + + await withBalanceChecks([order], 0, null, async () => { + const tx = shoyuContract.connect(seller).cook( + [0, 1, 0], + [0, 0, 0], + [ + transformationAdapter.interface.encodeFunctionData( + "transferERC721From", + [ + testERC721.address, + shoyuContract.address, + nftId, + TokenSource.WALLET, + "0x", + ] + ), + seaportAdapter.interface.encodeFunctionData( + "approveBeforeFulfill", + [ + [testERC721.address], + 0, + marketplaceContract.interface.encodeFunctionData( + "fulfillAdvancedOrder", + [order, [], toKey(false), shoyuContract.address] + ), + ] + ), + transformationAdapter.interface.encodeFunctionData( + "unwrapNativeToken", + [ + parseEther("1"), // amount + seller.address, // to + ] + ), + ] + ); + + const receipt = await (await tx).wait(); + + const sellerETHBalanceAfter = await provider.getBalance( + seller.address + ); + + expect( + sellerETHBalanceAfter.sub(sellerETHBalanceBefore).abs().toString() + ).to.eq( + receipt.effectiveGasPrice + .mul(receipt.gasUsed) + .sub(parseEther("1")) + .abs() + .toString() + ); + + await checkExpectedEvents( + tx, + receipt, + [ + { + order, + orderHash, + fulfiller: shoyuContract.address, + }, + ], + [ + { + item: consideration[0], + offerer: shoyuContract.address, + conduitKey: toKey(false), + }, + ] + ); + + return receipt; + }); + }); + + it("User accepts offer on ERC721 and swaps ERC20 -> ETH (with conduit)", async () => { + const nftId = await mintAndApprove721(seller, conduitOne.address); + + await conduitController + .connect(owner) + .updateChannel(conduitOne.address, shoyuContract.address, true); + + await mintAndApproveERC20( + buyer, + marketplaceContract.address, + parseEther("5") + ); + + // buyer creates offer for 1ERC721 at price of 1ERC20 + .1ERC20 fee + const offer = [ + getTestItem20(parseEther("1"), parseEther("1")), + getTestItem20(parseEther(".1"), parseEther(".1"), zone.address), + ]; + + const consideration = [getTestItem721(nftId, 1, 1, buyer.address)]; + + const { order, orderHash } = await createOrder( + buyer, + zone, + offer, + consideration, + 0 // FULL_OPEN + ); + + // buyer fills order through Shoyu contract + // and swaps ERC20 for ETH before filling the order + const sellerETHBalanceBefore = await provider.getBalance( + seller.address + ); + + await withBalanceChecks([order], 0, null, async () => { + const tx = shoyuContract.connect(seller).cook( + [0, 1, 0], + [0, 0, 0], + [ + transformationAdapter.interface.encodeFunctionData( + "transferERC721From", + [ + testERC721.address, + shoyuContract.address, + nftId, + TokenSource.CONDUIT, + conduitKeyOne, + ] + ), + seaportAdapter.interface.encodeFunctionData( + "approveBeforeFulfill", + [ + [testERC721.address], + 0, + marketplaceContract.interface.encodeFunctionData( + "fulfillAdvancedOrder", + [order, [], toKey(false), shoyuContract.address] + ), + ] + ), + transformationAdapter.interface.encodeFunctionData( + "swapExactIn", + [ + parseEther("1"), // amountIn + BigNumber.from(0), // amountOutMin + [testERC20.address, testWETH.address], // path + seller.address, // to + true, // unwrapNativeToken + ] + ), + ] + ); + + const receipt = await (await tx).wait(); + + const lpInterface = new Interface(IUNISWAPV2_ABI); + + const swapEvent = receipt.events + .filter((event: any) => { + try { + lpInterface.decodeEventLog("Swap", event.data, event.topics); + return true; + } catch (e) { + return false; + } + }) + .map((event: any) => + lpInterface.decodeEventLog("Swap", event.data, event.topics) + )[0]; + + const sellerETHBalanceAfter = await provider.getBalance( + seller.address + ); + + expect( + sellerETHBalanceAfter.sub(sellerETHBalanceBefore).abs().toString() + ).to.eq( + receipt.effectiveGasPrice + .mul(receipt.gasUsed) + .sub(swapEvent.amount0Out) + .abs() + .toString() + ); + + await checkExpectedEvents( + tx, + receipt, + [ + { + order, + orderHash, + fulfiller: shoyuContract.address, + }, + ], + [ + { + item: consideration[0], + offerer: shoyuContract.address, + conduitKey: toKey(false), + }, + ] + ); + + return receipt; + }); + }); + + it("User accepts offer on ERC1155 and swaps ERC20 -> ETH (with conduit)", async () => { + const { nftId, amount } = await mintAndApprove1155( + seller, + conduitOne.address + ); + + await conduitController + .connect(owner) + .updateChannel(conduitOne.address, shoyuContract.address, true); + + await mintAndApproveERC20( + buyer, + marketplaceContract.address, + parseEther("5") + ); + + // buyer creates offer for 1ERC721 at price of 1ERC20 + .1ERC20 fee + const offer = [ + getTestItem20(parseEther("1"), parseEther("1")), + getTestItem20(parseEther(".1"), parseEther(".1"), zone.address), + ]; + + const consideration = [ + getTestItem1155(nftId, amount, amount, undefined, buyer.address), + ]; + + const { order, orderHash } = await createOrder( + buyer, + zone, + offer, + consideration, + 0 // FULL_OPEN + ); + + // buyer fills order through Shoyu contract + // and swaps ERC20 for ETH before filling the order + const sellerETHBalanceBefore = await provider.getBalance( + seller.address + ); + + await withBalanceChecks([order], 0, null, async () => { + const tx = shoyuContract.connect(seller).cook( + [0, 1, 0], + [0, 0, 0], + [ + transformationAdapter.interface.encodeFunctionData( + "transferERC1155From", + [ + testERC1155.address, + shoyuContract.address, + nftId, + amount, + TokenSource.CONDUIT, + conduitKeyOne, + ] + ), + seaportAdapter.interface.encodeFunctionData( + "approveBeforeFulfill", + [ + [testERC1155.address], + 0, + marketplaceContract.interface.encodeFunctionData( + "fulfillAdvancedOrder", + [order, [], toKey(false), shoyuContract.address] + ), + ] + ), + transformationAdapter.interface.encodeFunctionData( + "swapExactIn", + [ + parseEther("1"), // amountIn + BigNumber.from(0), // amountOutMin + [testERC20.address, testWETH.address], // path + seller.address, // to + true, // unwrapNativeToken + ] + ), + ] + ); + + const receipt = await (await tx).wait(); + + const lpInterface = new Interface(IUNISWAPV2_ABI); + + const swapEvent = receipt.events + .filter((event: any) => { + try { + lpInterface.decodeEventLog("Swap", event.data, event.topics); + return true; + } catch (e) { + return false; + } + }) + .map((event: any) => + lpInterface.decodeEventLog("Swap", event.data, event.topics) + )[0]; + + const sellerETHBalanceAfter = await provider.getBalance( + seller.address + ); + + expect( + sellerETHBalanceAfter.sub(sellerETHBalanceBefore).abs().toString() + ).to.eq( + receipt.effectiveGasPrice + .mul(receipt.gasUsed) + .sub(swapEvent.amount0Out) + .abs() + .toString() + ); + + await checkExpectedEvents( + tx, + receipt, + [ + { + order, + orderHash, + fulfiller: shoyuContract.address, + }, + ], + [ + { + item: { ...consideration[0], amount }, + offerer: shoyuContract.address, + conduitKey: toKey(false), + operator: marketplaceContract.address, + }, + ] + ); + + return receipt; + }); + }); + + it("User accepts offer on ERC721 for ERC20 and deposits in bentobox", async () => { + const nftId = await mintAndApprove721(seller, shoyuContract.address); + + await mintAndApproveERC20( + buyer, + marketplaceContract.address, + parseEther("5") + ); + + // buyer creates offer for 1ERC721 at price of 1ERC20 + .1ERC20 fee + const offer = [ + getTestItem20(parseEther("1"), parseEther("1")), + getTestItem20(parseEther(".1"), parseEther(".1"), zone.address), + ]; + + const consideration = [getTestItem721(nftId, 1, 1, buyer.address)]; + + const { order, orderHash } = await createOrder( + buyer, + zone, + offer, + consideration, + 0 // FULL_OPEN + ); + + // buyer fills order through Shoyu contract + // and deposits received ERC20 in bentobox + await withBalanceChecks([order], 0, null, async () => { + const tx = shoyuContract.connect(seller).cook( + [0, 1, 0], + [0, 0, 0], + [ + transformationAdapter.interface.encodeFunctionData( + "transferERC721From", + [ + testERC721.address, + shoyuContract.address, + nftId, + TokenSource.WALLET, + "0x", + ] + ), + seaportAdapter.interface.encodeFunctionData( + "approveBeforeFulfill", + [ + [testERC721.address], + 0, + marketplaceContract.interface.encodeFunctionData( + "fulfillAdvancedOrder", + [order, [], toKey(false), shoyuContract.address] + ), + ] + ), + transformationAdapter.interface.encodeFunctionData( + "depositToBentoBox", + [ + true, + testERC20.address, // token + seller.address, // to + parseEther("1"), // amount + 0, // share + 0, // value + ] + ), + ] + ); + + const receipt = await (await tx).wait(); + + const bentoDepositEvent = receipt.events + .filter((event: any) => { + try { + bentobox.interface.decodeEventLog( + "LogDeposit", + event.data, + event.topics + ); + return true; + } catch (e) { + return false; + } + }) + .map((event: any) => + bentobox.interface.decodeEventLog( + "LogDeposit", + event.data, + event.topics + ) + )[0]; + + expect(bentoDepositEvent.amount.toString()).to.eq( + parseEther("1").toString() + ); + + const sellerBentoBalance = await bentobox.balanceOf( + testERC20.address, + seller.address + ); + + expect(sellerBentoBalance.toString()).to.eq( + parseEther("1").toString() + ); + + await checkExpectedEvents( + tx, + receipt, + [ + { + order, + orderHash, + fulfiller: shoyuContract.address, + }, + ], + [ + { + item: consideration[0], + offerer: shoyuContract.address, + conduitKey: toKey(false), + }, + ] + ); + + return receipt; + }); + }); + + it("User accepts offer on ERC721 for ERC20 (with conduit) and deposits in bentobox", async () => { + const nftId = await mintAndApprove721(seller, conduitOne.address); + + await conduitController + .connect(owner) + .updateChannel(conduitOne.address, shoyuContract.address, true); + + await mintAndApproveERC20( + buyer, + marketplaceContract.address, + parseEther("5") + ); + + // buyer creates offer for 1ERC721 at price of 1ERC20 + .1ERC20 fee + const offer = [ + getTestItem20(parseEther("1"), parseEther("1")), + getTestItem20(parseEther(".1"), parseEther(".1"), zone.address), + ]; + + const consideration = [getTestItem721(nftId, 1, 1, buyer.address)]; + + const { order, orderHash } = await createOrder( + buyer, + zone, + offer, + consideration, + 0 // FULL_OPEN + ); + + // buyer fills order through Shoyu contract + // and deposits received ERC20 in bentobox + await withBalanceChecks([order], 0, null, async () => { + const tx = shoyuContract.connect(seller).cook( + [0, 1, 0], + [0, 0, 0], + [ + transformationAdapter.interface.encodeFunctionData( + "transferERC721From", + [ + testERC721.address, + shoyuContract.address, + nftId, + TokenSource.CONDUIT, + conduitKeyOne, + ] + ), + seaportAdapter.interface.encodeFunctionData( + "approveBeforeFulfill", + [ + [testERC721.address], + 0, + marketplaceContract.interface.encodeFunctionData( + "fulfillAdvancedOrder", + [order, [], toKey(false), shoyuContract.address] + ), + ] + ), + transformationAdapter.interface.encodeFunctionData( + "depositToBentoBox", + [ + true, + testERC20.address, // token + seller.address, // to + parseEther("1"), // amount + 0, // share + 0, // value + ] + ), + ] + ); + + const receipt = await (await tx).wait(); + + const bentoDepositEvent = receipt.events + .filter((event: any) => { + try { + bentobox.interface.decodeEventLog( + "LogDeposit", + event.data, + event.topics + ); + return true; + } catch (e) { + return false; + } + }) + .map((event: any) => + bentobox.interface.decodeEventLog( + "LogDeposit", + event.data, + event.topics + ) + )[0]; + + expect(bentoDepositEvent.amount.toString()).to.eq( + parseEther("1").toString() + ); + + const sellerBentoBalance = await bentobox.balanceOf( + testERC20.address, + seller.address + ); + + expect(sellerBentoBalance.toString()).to.eq( + parseEther("1").toString() + ); + + await checkExpectedEvents( + tx, + receipt, + [ + { + order, + orderHash, + fulfiller: shoyuContract.address, + }, + ], + [ + { + item: consideration[0], + offerer: shoyuContract.address, + conduitKey: toKey(false), + }, + ] + ); + + return receipt; + }); + }); + + it("Reverts if order cannot be filled after swapping", async () => { + // seller creates listing for 1ERC721 at price of 1ETH + .1ETH fee + const nftId = await mintAndApprove721( + seller, + marketplaceContract.address + ); + + const offer = [getTestItem721(nftId)]; + + const consideration = [ + getItemETH(parseEther("1"), parseEther("1"), seller.address), + getItemETH(parseEther(".1"), parseEther(".1"), zone.address), + ]; + + // order is expired + const { order, orderHash, value } = await createOrder( + seller, + zone, + offer, + consideration, + 0, // FULL_OPEN + [], + "EXPIRED" + ); + + // buyer fills order through Shoyu contract + // and swaps ERC20 for ETH before filling the order + await mintAndApproveERC20( + buyer, + shoyuContract.address, + parseEther("5") + ); + + await expect( + shoyuContract.connect(buyer).cook( + [0, 1], + [0, value], + [ + transformationAdapter.interface.encodeFunctionData( + "swapExactOut", + [ + value, // amountOut + MaxUint256, // amountInMax + [testERC20.address, testWETH.address], // path + shoyuContract.address, // to + TokenSource.WALLET, // tokenSource + "0x", // transferData + true, // unwrapNativeToken + ] + ), + seaportAdapter.interface.encodeFunctionData("fulfill", [ + value, + marketplaceContract.interface.encodeFunctionData( + "fulfillAdvancedOrder", + [order, [], toKey(false), buyer.address] + ), + ]), + ] + ) + ).to.be.reverted; + }); + }); + }); +}); diff --git a/test/utils/contracts.ts b/test/utils/contracts.ts new file mode 100644 index 00000000..8eefbc74 --- /dev/null +++ b/test/utils/contracts.ts @@ -0,0 +1,27 @@ +import { ethers } from "hardhat"; +import { Contract } from "ethers"; +import { JsonRpcSigner } from "@ethersproject/providers"; +import * as dotenv from "dotenv"; + +dotenv.config(); + +export const deployContract = async ( + name: string, + signer: JsonRpcSigner, + ...args: any[] +): Promise => { + const references = new Map([ + ["Consideration", "ReferenceConsideration"], + ["Conduit", "ReferenceConduit"], + ["ConduitController", "ReferenceConduitController"], + ]); + + const nameWithReference = + process.env.REFERENCE && references.has(name) + ? references.get(name) || name + : name; + + const f = await ethers.getContractFactory(nameWithReference, signer); + const c = await f.deploy(...args); + return c as C; +}; diff --git a/test/utils/contsants.ts b/test/utils/contsants.ts new file mode 100644 index 00000000..d8777d16 --- /dev/null +++ b/test/utils/contsants.ts @@ -0,0 +1,11 @@ +export const ACTION_LEGACY_SWAP_EXACT_OUT = 0; +export const ACTION_LEGACY_SWAP_EXACT_IN = 1; +export const ACTION_TRIDENT_SWAP_EXACT_OUT = 2; +export const ACTION_TRIDENT_SWAP_EXACT_IN = 3; +export const ACTION_SEAPORT_FULFILLMENT = 4; + +export enum TokenSource { + WALLET, + CONDUIT, + BENTO, +} diff --git a/test/utils/criteria.js b/test/utils/criteria.js new file mode 100644 index 00000000..56149f6d --- /dev/null +++ b/test/utils/criteria.js @@ -0,0 +1,105 @@ +const { ethers } = require("ethers"); +const { bufferToHex, keccak256 } = require("ethereumjs-util"); + +const merkleTree = (tokenIds) => { + const elements = tokenIds + .map((tokenId) => + Buffer.from(tokenId.toHexString().slice(2).padStart(64, "0"), "hex") + ) + .sort(Buffer.compare) + .filter((el, idx, arr) => { + return idx === 0 || !arr[idx - 1].equals(el); + }); + + const bufferElementPositionIndex = elements.reduce((memo, el, index) => { + memo[bufferToHex(el)] = index; + return memo; + }, {}); + + // Create layers + const layers = getLayers(elements); + + const root = bufferToHex(layers[layers.length - 1][0]); + + const proofs = Object.fromEntries( + elements.map((el) => [ + ethers.BigNumber.from("0x" + el.toString("hex")).toString(), + getHexProof(el, bufferElementPositionIndex, layers), + ]) + ); + + const maxProofLength = Math.max( + ...Object.values(proofs).map((i) => i.length) + ); + + return { + root, + proofs, + maxProofLength, + }; +}; + +const getLayers = (elements) => { + if (elements.length === 0) { + throw new Error("empty tree"); + } + + const layers = []; + layers.push(elements.map((el) => keccak256(el))); + + // Get next layer until we reach the root + while (layers[layers.length - 1].length > 1) { + layers.push(getNextLayer(layers[layers.length - 1])); + } + + return layers; +}; + +const getNextLayer = (elements) => { + return elements.reduce((layer, el, idx, arr) => { + if (idx % 2 === 0) { + // Hash the current element with its pair element + layer.push(combinedHash(el, arr[idx + 1])); + } + + return layer; + }, []); +}; + +const combinedHash = (first, second) => { + if (!first) { + return second; + } + if (!second) { + return first; + } + + return keccak256(Buffer.concat([first, second].sort(Buffer.compare))); +}; + +const getHexProof = (el, bufferElementPositionIndex, layers) => { + let idx = bufferElementPositionIndex[bufferToHex(el)]; + + if (typeof idx !== "number") { + throw new Error("Element does not exist in Merkle tree"); + } + + const proofBuffer = layers.reduce((proof, layer) => { + const pairIdx = idx % 2 === 0 ? idx + 1 : idx - 1; + const pairElement = pairIdx < layer.length ? layer[pairIdx] : null; + + if (pairElement) { + proof.push(pairElement); + } + + idx = Math.floor(idx / 2); + + return proof; + }, []); + + return proofBuffer.map((el) => "0x" + el.toString("hex")); +}; + +module.exports = Object.freeze({ + merkleTree, +}); diff --git a/test/utils/encoding.ts b/test/utils/encoding.ts new file mode 100644 index 00000000..8bfa67c5 --- /dev/null +++ b/test/utils/encoding.ts @@ -0,0 +1,376 @@ +import { randomBytes as nodeRandomBytes } from "crypto"; +import { utils, BigNumber, constants, ContractTransaction } from "ethers"; +import { getAddress, keccak256, toUtf8Bytes } from "ethers/lib/utils"; +import { + BasicOrderParameters, + BigNumberish, + ConsiderationItem, + CriteriaResolver, + FulfillmentComponent, + OfferItem, + Order, + OrderComponents, +} from "./types"; + +export { BigNumberish }; + +const SeededRNG = require("./seeded-rng"); + +const GAS_REPORT_MODE = process.env.REPORT_GAS; + +let randomBytes: (n: number) => string; +if (GAS_REPORT_MODE) { + const srng = SeededRNG.create("gas-report"); + randomBytes = srng.randomBytes; +} else { + randomBytes = (n: number) => nodeRandomBytes(n).toString("hex"); +} + +// const randomBytes + +export const randomHex = (bytes = 32) => `0x${randomBytes(bytes)}`; + +export const random128 = () => toBN(randomHex(16)); + +const hexRegex = /[A-Fa-fx]/g; + +export const toHex = (n: BigNumberish, numBytes: number = 0) => { + const asHexString = BigNumber.isBigNumber(n) + ? n.toHexString().slice(2) + : typeof n === "string" + ? hexRegex.test(n) + ? n.replace(/0x/, "") + : (+n).toString(16) + : (+n).toString(16); + return `0x${asHexString.padStart(numBytes * 2, "0")}`; +}; + +export const baseFee = async (tx: ContractTransaction) => { + const data = tx.data; + const { gasUsed } = await tx.wait(); + const bytes = toHex(data) + .slice(2) + .match(/.{1,2}/g) as string[]; + const numZero = bytes.filter((b) => b === "00").length; + return ( + gasUsed.toNumber() - (21000 + (numZero * 4 + (bytes.length - numZero) * 16)) + ); +}; + +export const randomBN = (bytes: number = 16) => toBN(randomHex(bytes)); + +export const toBN = (n: BigNumberish) => BigNumber.from(toHex(n)); + +export const toAddress = (n: BigNumberish) => getAddress(toHex(n, 20)); + +export const toKey = (n: BigNumberish) => toHex(n, 32); + +export const convertSignatureToEIP2098 = (signature: string) => { + if (signature.length === 130) { + return signature; + } + + if (signature.length !== 132) { + throw Error("invalid signature length (must be 64 or 65 bytes)"); + } + + return utils.splitSignature(signature).compact; +}; + +export const getBasicOrderParameters = ( + basicOrderRouteType: number, + order: Order, + fulfillerConduitKey = false, + tips = [] +): BasicOrderParameters => ({ + offerer: order.parameters.offerer, + zone: order.parameters.zone, + basicOrderType: order.parameters.orderType + 4 * basicOrderRouteType, + offerToken: order.parameters.offer[0].token, + offerIdentifier: order.parameters.offer[0].identifierOrCriteria, + offerAmount: order.parameters.offer[0].endAmount, + considerationToken: order.parameters.consideration[0].token, + considerationIdentifier: + order.parameters.consideration[0].identifierOrCriteria, + considerationAmount: order.parameters.consideration[0].endAmount, + startTime: order.parameters.startTime, + endTime: order.parameters.endTime, + zoneHash: order.parameters.zoneHash, + salt: order.parameters.salt, + totalOriginalAdditionalRecipients: BigNumber.from( + order.parameters.consideration.length - 1 + ), + signature: order.signature, + offererConduitKey: order.parameters.conduitKey, + fulfillerConduitKey: toKey(fulfillerConduitKey), + additionalRecipients: [ + ...order.parameters.consideration + .slice(1) + .map(({ endAmount, recipient }) => ({ amount: endAmount, recipient })), + ...tips, + ], +}); + +export const getOfferOrConsiderationItem = < + RecipientType extends string | undefined = undefined +>( + itemType: number = 0, + token: string = constants.AddressZero, + identifierOrCriteria: BigNumberish = 0, + startAmount: BigNumberish = 1, + endAmount: BigNumberish = 1, + recipient?: RecipientType +): RecipientType extends string ? ConsiderationItem : OfferItem => { + const offerItem: OfferItem = { + itemType, + token, + identifierOrCriteria: toBN(identifierOrCriteria), + startAmount: toBN(startAmount), + endAmount: toBN(endAmount), + }; + if (typeof recipient === "string") { + return { + ...offerItem, + recipient: recipient as string, + } as ConsiderationItem; + } + return offerItem as any; +}; + +export const buildOrderStatus = ( + ...arr: Array +) => { + const values = arr.map((v) => (typeof v === "number" ? toBN(v) : v)); + return ["isValidated", "isCancelled", "totalFilled", "totalSize"].reduce( + (obj, key, i) => ({ + ...obj, + [key]: values[i], + [i]: values[i], + }), + {} + ); +}; + +export const getItemETH = ( + startAmount: BigNumberish = 1, + endAmount: BigNumberish = 1, + recipient?: string +) => + getOfferOrConsiderationItem( + 0, + constants.AddressZero, + 0, + toBN(startAmount), + toBN(endAmount), + recipient + ); + +export const getItem721 = ( + token: string, + identifierOrCriteria: BigNumberish, + startAmount: number = 1, + endAmount: number = 1, + recipient?: string +) => + getOfferOrConsiderationItem( + 2, + token, + identifierOrCriteria, + startAmount, + endAmount, + recipient + ); + +export const toFulfillmentComponents = ( + arr: number[][] +): FulfillmentComponent[] => + arr.map(([orderIndex, itemIndex]) => ({ orderIndex, itemIndex })); + +export const toFulfillment = ( + offerArr: number[][], + considerationsArr: number[][] +): { + offerComponents: FulfillmentComponent[]; + considerationComponents: FulfillmentComponent[]; +} => ({ + offerComponents: toFulfillmentComponents(offerArr), + considerationComponents: toFulfillmentComponents(considerationsArr), +}); + +export const buildResolver = ( + orderIndex: number, + side: 0 | 1, + index: number, + identifier: BigNumber, + criteriaProof: string[] +): CriteriaResolver => ({ + orderIndex, + side, + index, + identifier, + criteriaProof, +}); + +export const calculateOrderHash = (orderComponents: OrderComponents) => { + const offerItemTypeString = + "OfferItem(uint8 itemType,address token,uint256 identifierOrCriteria,uint256 startAmount,uint256 endAmount)"; + const considerationItemTypeString = + "ConsiderationItem(uint8 itemType,address token,uint256 identifierOrCriteria,uint256 startAmount,uint256 endAmount,address recipient)"; + const orderComponentsPartialTypeString = + "OrderComponents(address offerer,address zone,OfferItem[] offer,ConsiderationItem[] consideration,uint8 orderType,uint256 startTime,uint256 endTime,bytes32 zoneHash,uint256 salt,bytes32 conduitKey,uint256 counter)"; + const orderTypeString = `${orderComponentsPartialTypeString}${considerationItemTypeString}${offerItemTypeString}`; + + const offerItemTypeHash = keccak256(toUtf8Bytes(offerItemTypeString)); + const considerationItemTypeHash = keccak256( + toUtf8Bytes(considerationItemTypeString) + ); + const orderTypeHash = keccak256(toUtf8Bytes(orderTypeString)); + + const offerHash = keccak256( + "0x" + + orderComponents.offer + .map((offerItem) => { + return keccak256( + "0x" + + [ + offerItemTypeHash.slice(2), + offerItem.itemType.toString().padStart(64, "0"), + offerItem.token.slice(2).padStart(64, "0"), + toBN(offerItem.identifierOrCriteria) + .toHexString() + .slice(2) + .padStart(64, "0"), + toBN(offerItem.startAmount) + .toHexString() + .slice(2) + .padStart(64, "0"), + toBN(offerItem.endAmount) + .toHexString() + .slice(2) + .padStart(64, "0"), + ].join("") + ).slice(2); + }) + .join("") + ); + + const considerationHash = keccak256( + "0x" + + orderComponents.consideration + .map((considerationItem) => { + return keccak256( + "0x" + + [ + considerationItemTypeHash.slice(2), + considerationItem.itemType.toString().padStart(64, "0"), + considerationItem.token.slice(2).padStart(64, "0"), + toBN(considerationItem.identifierOrCriteria) + .toHexString() + .slice(2) + .padStart(64, "0"), + toBN(considerationItem.startAmount) + .toHexString() + .slice(2) + .padStart(64, "0"), + toBN(considerationItem.endAmount) + .toHexString() + .slice(2) + .padStart(64, "0"), + considerationItem.recipient.slice(2).padStart(64, "0"), + ].join("") + ).slice(2); + }) + .join("") + ); + + const derivedOrderHash = keccak256( + "0x" + + [ + orderTypeHash.slice(2), + orderComponents.offerer.slice(2).padStart(64, "0"), + orderComponents.zone.slice(2).padStart(64, "0"), + offerHash.slice(2), + considerationHash.slice(2), + orderComponents.orderType.toString().padStart(64, "0"), + toBN(orderComponents.startTime) + .toHexString() + .slice(2) + .padStart(64, "0"), + toBN(orderComponents.endTime).toHexString().slice(2).padStart(64, "0"), + orderComponents.zoneHash.slice(2), + orderComponents.salt.slice(2).padStart(64, "0"), + orderComponents.conduitKey.slice(2).padStart(64, "0"), + toBN(orderComponents.counter).toHexString().slice(2).padStart(64, "0"), + ].join("") + ); + + return derivedOrderHash; +}; + +export const getBasicOrderExecutions = ( + order: Order, + fulfiller: string, + fulfillerConduitKey: string +) => { + const { offerer, conduitKey, offer, consideration } = order.parameters; + const offerItem = offer[0]; + const considerationItem = consideration[0]; + const executions = [ + { + item: { + ...offerItem, + amount: offerItem.endAmount, + recipient: fulfiller, + }, + offerer: offerer, + conduitKey: conduitKey, + }, + { + item: { + ...considerationItem, + amount: considerationItem.endAmount, + }, + offerer: fulfiller, + conduitKey: fulfillerConduitKey, + }, + ]; + if (consideration.length > 1) { + for (const additionalRecipient of consideration.slice(1)) { + const execution = { + item: { + ...additionalRecipient, + amount: additionalRecipient.endAmount, + }, + offerer: fulfiller, + conduitKey: fulfillerConduitKey, + }; + if (additionalRecipient.itemType === offerItem.itemType) { + execution.offerer = offerer; + execution.conduitKey = conduitKey; + executions[0].item.amount = executions[0].item.amount.sub( + execution.item.amount + ); + } + executions.push(execution); + } + } + return executions; +}; + +export const defaultBuyNowMirrorFulfillment = [ + [[[0, 0]], [[1, 0]]], + [[[1, 0]], [[0, 0]]], + [[[1, 0]], [[0, 1]]], + [[[1, 0]], [[0, 2]]], +].map(([offerArr, considerationArr]) => + toFulfillment(offerArr, considerationArr) +); + +export const defaultAcceptOfferMirrorFulfillment = [ + [[[1, 0]], [[0, 0]]], + [[[0, 0]], [[1, 0]]], + [[[0, 0]], [[0, 1]]], + [[[0, 0]], [[0, 2]]], +].map(([offerArr, considerationArr]) => + toFulfillment(offerArr, considerationArr) +); diff --git a/test/utils/fixtures/conduit.ts b/test/utils/fixtures/conduit.ts new file mode 100644 index 00000000..2c4d3a42 --- /dev/null +++ b/test/utils/fixtures/conduit.ts @@ -0,0 +1,116 @@ +/* eslint-disable camelcase */ +import { expect } from "chai"; +import { constants, Wallet } from "ethers"; +import { getCreate2Address, keccak256 } from "ethers/lib/utils"; +import hre, { ethers } from "hardhat"; +import { + ConduitControllerInterface, + ImmutableCreate2FactoryInterface, +} from "../../../typechain-types"; +import { deployContract } from "../contracts"; +import { randomHex } from "../encoding"; +import { whileImpersonating } from "../impersonate"; + +const deployConstants = require("../../../constants/constants"); + +export const conduitFixture = async ( + create2Factory: ImmutableCreate2FactoryInterface, + owner: Wallet +) => { + let conduitController: ConduitControllerInterface; + let conduitImplementation: any; + if (process.env.REFERENCE) { + conduitImplementation = await ethers.getContractFactory("ReferenceConduit"); + conduitController = await deployContract("ConduitController", owner as any); + } else { + conduitImplementation = await ethers.getContractFactory("Conduit"); + + // Deploy conduit controller through efficient create2 factory + const conduitControllerFactory = await ethers.getContractFactory( + "ConduitController" + ); + + const conduitControllerAddress = await create2Factory.findCreate2Address( + deployConstants.CONDUIT_CONTROLLER_CREATION_SALT, + conduitControllerFactory.bytecode + ); + + let { gasLimit } = await ethers.provider.getBlock("latest"); + + if ((hre as any).__SOLIDITY_COVERAGE_RUNNING) { + gasLimit = ethers.BigNumber.from(300_000_000); + } + await create2Factory.safeCreate2( + deployConstants.CONDUIT_CONTROLLER_CREATION_SALT, + conduitControllerFactory.bytecode, + { + gasLimit, + } + ); + + conduitController = (await ethers.getContractAt( + "ConduitController", + conduitControllerAddress, + owner + )) as any; + } + const conduitCodeHash = keccak256(conduitImplementation.bytecode); + + const conduitKeyOne = `${owner.address}000000000000000000000000`; + + await conduitController.createConduit(conduitKeyOne, owner.address); + + const { conduit: conduitOneAddress, exists } = + await conduitController.getConduit(conduitKeyOne); + + // eslint-disable-next-line no-unused-expressions + expect(exists).to.be.true; + + const conduitOne = conduitImplementation.attach(conduitOneAddress); + + const getTransferSender = (account: string, conduitKey: string) => { + if (!conduitKey || conduitKey === constants.HashZero) { + return account; + } + return getCreate2Address( + conduitController.address, + conduitKey, + conduitCodeHash + ); + }; + + const deployNewConduit = async (owner: Wallet, conduitKey?: string) => { + // Create a conduit key with a random salt + const assignedConduitKey = + conduitKey || owner.address + randomHex(12).slice(2); + + const { conduit: tempConduitAddress } = await conduitController.getConduit( + assignedConduitKey + ); + + await whileImpersonating(owner.address, ethers.provider, async () => { + await expect( + conduitController + .connect(owner) + .createConduit(assignedConduitKey, constants.AddressZero) + ).to.be.revertedWith("InvalidInitialOwner"); + + await conduitController + .connect(owner) + .createConduit(assignedConduitKey, owner.address); + }); + + const tempConduit = conduitImplementation.attach(tempConduitAddress); + return tempConduit; + }; + + return { + conduitController, + conduitImplementation, + conduitCodeHash, + conduitKeyOne, + conduitOne, + getTransferSender, + deployNewConduit, + }; +}; diff --git a/test/utils/fixtures/create2.ts b/test/utils/fixtures/create2.ts new file mode 100644 index 00000000..95c0d0e4 --- /dev/null +++ b/test/utils/fixtures/create2.ts @@ -0,0 +1,73 @@ +import { expect } from "chai"; +import { Wallet } from "ethers"; +import hre, { ethers } from "hardhat"; +import { ImmutableCreate2FactoryInterface } from "../../../typechain-types"; +import { faucet } from "../impersonate"; + +const deployConstants = require("../../../constants/constants"); + +export const create2FactoryFixture = async (owner: Wallet) => { + // Deploy keyless create2 deployer + await faucet( + deployConstants.KEYLESS_CREATE2_DEPLOYER_ADDRESS, + ethers.provider + ); + await ethers.provider.sendTransaction( + deployConstants.KEYLESS_CREATE2_DEPLOYMENT_TRANSACTION + ); + let deployedCode = await ethers.provider.getCode( + deployConstants.KEYLESS_CREATE2_ADDRESS + ); + expect(deployedCode).to.equal(deployConstants.KEYLESS_CREATE2_RUNTIME_CODE); + + let { gasLimit } = await ethers.provider.getBlock("latest"); + + if ((hre as any).__SOLIDITY_COVERAGE_RUNNING) { + gasLimit = ethers.BigNumber.from(300_000_000); + } + + // Deploy inefficient deployer through keyless + await owner.sendTransaction({ + to: deployConstants.KEYLESS_CREATE2_ADDRESS, + data: deployConstants.IMMUTABLE_CREATE2_FACTORY_CREATION_CODE, + gasLimit, + }); + deployedCode = await ethers.provider.getCode( + deployConstants.INEFFICIENT_IMMUTABLE_CREATE2_FACTORY_ADDRESS + ); + expect(ethers.utils.keccak256(deployedCode)).to.equal( + deployConstants.IMMUTABLE_CREATE2_FACTORY_RUNTIME_HASH + ); + + const inefficientFactory = await ethers.getContractAt( + "ImmutableCreate2FactoryInterface", + deployConstants.INEFFICIENT_IMMUTABLE_CREATE2_FACTORY_ADDRESS, + owner + ); + + // Deploy effecient deployer through inefficient deployer + await inefficientFactory + .connect(owner) + .safeCreate2( + deployConstants.IMMUTABLE_CREATE2_FACTORY_SALT, + deployConstants.IMMUTABLE_CREATE2_FACTORY_CREATION_CODE, + { + gasLimit, + } + ); + + deployedCode = await ethers.provider.getCode( + deployConstants.IMMUTABLE_CREATE2_FACTORY_ADDRESS + ); + expect(ethers.utils.keccak256(deployedCode)).to.equal( + deployConstants.IMMUTABLE_CREATE2_FACTORY_RUNTIME_HASH + ); + const create2Factory: ImmutableCreate2FactoryInterface = + await ethers.getContractAt( + "ImmutableCreate2FactoryInterface", + deployConstants.IMMUTABLE_CREATE2_FACTORY_ADDRESS, + owner + ); + + return create2Factory; +}; diff --git a/test/utils/fixtures/index.ts b/test/utils/fixtures/index.ts new file mode 100644 index 00000000..38f6e525 --- /dev/null +++ b/test/utils/fixtures/index.ts @@ -0,0 +1,976 @@ +/* eslint-disable no-unused-expressions */ +import { expect } from "chai"; +import { + BigNumber, + constants, + Contract, + ContractReceipt, + ContractTransaction, + Wallet, +} from "ethers"; +import { ethers } from "hardhat"; +import { deployContract } from "../contracts"; +import { toBN } from "../encoding"; +import { AdvancedOrder, CriteriaResolver } from "../types"; +import { conduitFixture } from "./conduit"; +import { create2FactoryFixture } from "./create2"; +import { marketplaceFixture } from "./marketplace"; +import { tokensFixture } from "./tokens"; + +export { conduitFixture } from "./conduit"; +export { + fixtureERC20, + fixtureERC721, + fixtureERC1155, + tokensFixture, +} from "./tokens"; + +const { provider } = ethers; + +export const seaportFixture = async (owner: Wallet) => { + const EIP1271WalletFactory = await ethers.getContractFactory("EIP1271Wallet"); + const reenterer = await deployContract("Reenterer", owner as any); + const { chainId } = await provider.getNetwork(); + const create2Factory = await create2FactoryFixture(owner); + const { + conduitController, + conduitImplementation, + conduitKeyOne, + conduitOne, + getTransferSender, + deployNewConduit, + } = await conduitFixture(create2Factory, owner); + + const { + testERC20, + mintAndApproveERC20, + getTestItem20, + testERC721, + set721ApprovalForAll, + mint721, + mint721s, + mintAndApprove721, + getTestItem721, + getTestItem721WithCriteria, + testERC1155, + set1155ApprovalForAll, + mint1155, + mintAndApprove1155, + getTestItem1155WithCriteria, + getTestItem1155, + testERC1155Two, + tokenByType, + createTransferWithApproval, + } = await tokensFixture(owner as any); + + const { + marketplaceContract, + directMarketplaceContract, + stubZone, + domainData, + signOrder, + createOrder, + createMirrorBuyNowOrder, + createMirrorAcceptOfferOrder, + } = await marketplaceFixture( + create2Factory, + conduitController, + conduitOne, + chainId, + owner + ); + + const withBalanceChecks = async ( + ordersArray: AdvancedOrder[], // TODO: include order statuses to account for partial fills + additionalPayouts: 0 | BigNumber, + criteriaResolvers: CriteriaResolver[] = [], + fn: () => Promise, + multiplier = 1 + ) => { + const ordersClone: AdvancedOrder[] = JSON.parse( + JSON.stringify(ordersArray as any) + ) as any; + for (const [i, order] of Object.entries(ordersClone) as any as [ + number, + AdvancedOrder + ][]) { + order.parameters.startTime = ordersArray[i].parameters.startTime; + order.parameters.endTime = ordersArray[i].parameters.endTime; + + for (const [j, offerItem] of Object.entries( + order.parameters.offer + ) as any) { + offerItem.startAmount = ordersArray[i].parameters.offer[j].startAmount; + offerItem.endAmount = ordersArray[i].parameters.offer[j].endAmount; + } + + for (const [j, considerationItem] of Object.entries( + order.parameters.consideration + ) as any) { + considerationItem.startAmount = + ordersArray[i].parameters.consideration[j].startAmount; + considerationItem.endAmount = + ordersArray[i].parameters.consideration[j].endAmount; + } + } + + if (criteriaResolvers) { + for (const { orderIndex, side, index, identifier } of criteriaResolvers) { + const itemType = + ordersClone[orderIndex].parameters[ + side === 0 ? "offer" : "consideration" + ][index].itemType; + if (itemType < 4) { + console.error("APPLYING CRITERIA TO NON-CRITERIA-BASED ITEM"); + process.exit(1); + } + + ordersClone[orderIndex].parameters[ + side === 0 ? "offer" : "consideration" + ][index].itemType = itemType - 2; + ordersClone[orderIndex].parameters[ + side === 0 ? "offer" : "consideration" + ][index].identifierOrCriteria = identifier; + } + } + + const allOfferedItems = ordersClone + .map((x) => + x.parameters.offer.map((offerItem) => ({ + ...offerItem, + account: x.parameters.offerer, + numerator: x.numerator, + denominator: x.denominator, + startTime: x.parameters.startTime, + endTime: x.parameters.endTime, + })) + ) + .flat(); + + const allReceivedItems = ordersClone + .map((x) => + x.parameters.consideration.map((considerationItem) => ({ + ...considerationItem, + numerator: x.numerator, + denominator: x.denominator, + startTime: x.parameters.startTime, + endTime: x.parameters.endTime, + })) + ) + .flat(); + + for (const offeredItem of allOfferedItems as any[]) { + if (offeredItem.itemType > 3) { + console.error("CRITERIA ON OFFERED ITEM NOT RESOLVED"); + process.exit(1); + } + + if (offeredItem.itemType === 0) { + // ETH + offeredItem.initialBalance = await provider.getBalance( + offeredItem.account + ); + } else if (offeredItem.itemType === 3) { + // ERC1155 + offeredItem.initialBalance = await tokenByType[ + offeredItem.itemType + ].balanceOf(offeredItem.account, offeredItem.identifierOrCriteria); + } else if (offeredItem.itemType < 4) { + const token = new Contract( + offeredItem.token, + tokenByType[offeredItem.itemType].interface, + provider + ); + offeredItem.initialBalance = await token.balanceOf(offeredItem.account); + } + + if (offeredItem.itemType === 2) { + // ERC721 + offeredItem.ownsItemBefore = + (await tokenByType[offeredItem.itemType].ownerOf( + offeredItem.identifierOrCriteria + )) === offeredItem.account; + } + } + + for (const receivedItem of allReceivedItems as any[]) { + if (receivedItem.itemType > 3) { + console.error( + "CRITERIA-BASED BALANCE RECEIVED CHECKS NOT IMPLEMENTED YET" + ); + process.exit(1); + } + + if (receivedItem.itemType === 0) { + // ETH + receivedItem.initialBalance = await provider.getBalance( + receivedItem.recipient + ); + } else if (receivedItem.itemType === 3) { + // ERC1155 + receivedItem.initialBalance = await tokenByType[ + receivedItem.itemType + ].balanceOf(receivedItem.recipient, receivedItem.identifierOrCriteria); + } else { + const token = new Contract( + receivedItem.token, + tokenByType[receivedItem.itemType].interface, + provider + ); + receivedItem.initialBalance = await token.balanceOf( + receivedItem.recipient + ); + } + + if (receivedItem.itemType === 2) { + // ERC721 + receivedItem.ownsItemBefore = + (await tokenByType[receivedItem.itemType].ownerOf( + receivedItem.identifierOrCriteria + )) === receivedItem.recipient; + } + } + + const receipt = await fn(); + + const from = receipt.from; + const gasUsed = receipt.gasUsed; + + for (const offeredItem of allOfferedItems as any[]) { + if (offeredItem.account === from && offeredItem.itemType === 0) { + offeredItem.initialBalance = offeredItem.initialBalance.sub(gasUsed); + } + } + + for (const receivedItem of allReceivedItems as any[]) { + if (receivedItem.recipient === from && receivedItem.itemType === 0) { + receivedItem.initialBalance = receivedItem.initialBalance.sub(gasUsed); + } + } + + for (const offeredItem of allOfferedItems as any[]) { + if (offeredItem.itemType > 3) { + console.error("CRITERIA-BASED BALANCE OFFERED CHECKS NOT MET"); + process.exit(1); + } + + if (offeredItem.itemType === 0) { + // ETH + offeredItem.finalBalance = await provider.getBalance( + offeredItem.account + ); + } else if (offeredItem.itemType === 3) { + // ERC1155 + offeredItem.finalBalance = await tokenByType[ + offeredItem.itemType + ].balanceOf(offeredItem.account, offeredItem.identifierOrCriteria); + } else if (offeredItem.itemType < 3) { + // TODO: criteria-based + const token = new Contract( + offeredItem.token, + tokenByType[offeredItem.itemType].interface, + provider + ); + offeredItem.finalBalance = await token.balanceOf(offeredItem.account); + } + + if (offeredItem.itemType === 2) { + // ERC721 + offeredItem.ownsItemAfter = + (await tokenByType[offeredItem.itemType].ownerOf( + offeredItem.identifierOrCriteria + )) === offeredItem.account; + } + } + + for (const receivedItem of allReceivedItems as any[]) { + if (receivedItem.itemType > 3) { + console.error("CRITERIA-BASED BALANCE RECEIVED CHECKS NOT MET"); + process.exit(1); + } + + if (receivedItem.itemType === 0) { + // ETH + receivedItem.finalBalance = await provider.getBalance( + receivedItem.recipient + ); + } else if (receivedItem.itemType === 3) { + // ERC1155 + receivedItem.finalBalance = await tokenByType[ + receivedItem.itemType + ].balanceOf(receivedItem.recipient, receivedItem.identifierOrCriteria); + } else { + const token = new Contract( + receivedItem.token, + tokenByType[receivedItem.itemType].interface, + provider + ); + receivedItem.finalBalance = await token.balanceOf( + receivedItem.recipient + ); + } + + if (receivedItem.itemType === 2) { + // ERC721 + receivedItem.ownsItemAfter = + (await tokenByType[receivedItem.itemType].ownerOf( + receivedItem.identifierOrCriteria + )) === receivedItem.recipient; + } + } + + const { timestamp } = await provider.getBlock(receipt.blockHash); + + // aggregate expected and received balances offer items of the same token and sender + const aggregatedOfferItemBalances = (allOfferedItems as any[]).reduce( + (prev, cur) => { + const duration = toBN(cur.endTime).sub(cur.startTime); + const elapsed = toBN(timestamp).sub(cur.startTime); + const remaining = duration.sub(elapsed); + + prev[cur.token + ":" + cur.account] = { + expectedTokenBalance: toBN( + prev?.[cur.token + ":" + cur.account]?.expectedTokenBalance ?? 0 + ).add( + !additionalPayouts + ? toBN(cur.startAmount) + .mul(remaining) + .add(toBN(cur.endAmount).mul(elapsed)) + .div(duration) + .mul(cur.numerator) + .div(cur.denominator) + .mul(multiplier) + : additionalPayouts.add(cur.endAmount) + ), + receivedTokenBalance: + prev?.[cur.token + ":" + cur.account]?.receivedTokenBalance ?? + cur.initialBalance.sub(cur.finalBalance), + }; + + if (cur.itemType === 2) { + // ERC721 + expect(cur.ownsItemBefore).to.equal(true); + expect(cur.ownsItemAfter).to.equal(false); + } + + return prev; + }, + {} + ); + + Object.values(aggregatedOfferItemBalances).forEach( + (aggregatedBalance: any) => + expect(aggregatedBalance.receivedTokenBalance.toString()).to.equal( + aggregatedBalance.expectedTokenBalance.toString() + ) + ); + + // aggregate expected and received balances for received items of same token and recipient + const aggregatedReceivedItemBalances = (allReceivedItems as any[]).reduce( + (prev, cur) => { + const duration = toBN(cur.endTime).sub(cur.startTime); + const elapsed = toBN(timestamp).sub(cur.startTime); + const remaining = duration.sub(elapsed); + + prev[cur.token + ":" + cur.recipient] = { + expectedTokenBalance: ( + prev?.[cur.token + ":" + cur.recipient]?.expectedTokenBalance ?? + toBN(0) + ).add( + toBN(cur.startAmount) + .mul(remaining) + .add(toBN(cur.endAmount).mul(elapsed)) + .add(duration.sub(1)) + .div(duration) + .mul(cur.numerator) + .div(cur.denominator) + .mul(multiplier) + ), + receivedTokenBalance: + prev?.[cur.token + ":" + cur.recipient]?.receivedTokenBalance ?? + cur.finalBalance.sub(cur.initialBalance), + }; + + if (cur.itemType === 2) { + // ERC721 + expect(cur.ownsItemBefore).to.equal(false); + expect(cur.ownsItemAfter).to.equal(true); + } + + return prev; + }, + {} + ); + + Object.values(aggregatedReceivedItemBalances).forEach( + (aggregatedBalance: any) => + expect(aggregatedBalance.receivedTokenBalance.toString()).to.equal( + aggregatedBalance.expectedTokenBalance.toString() + ) + ); + + // This doesn't aggregate items of the same kind and address + // for (const offeredItem of allOfferedItems as any[]) { + // const duration = toBN(offeredItem.endTime).sub(offeredItem.startTime); + // const elapsed = toBN(timestamp).sub(offeredItem.startTime); + // const remaining = duration.sub(elapsed); + + // if (offeredItem.itemType < 4) { + // // TODO: criteria-based + // if (!additionalPayouts) { + // expect( + // offeredItem.initialBalance.sub(offeredItem.finalBalance).toString() + // ).to.equal( + // toBN(offeredItem.startAmount) + // .mul(remaining) + // .add(toBN(offeredItem.endAmount).mul(elapsed)) + // .div(duration) + // .mul(offeredItem.numerator) + // .div(offeredItem.denominator) + // .mul(multiplier) + // .toString() + // ); + // } else { + // expect( + // offeredItem.initialBalance.sub(offeredItem.finalBalance).toString() + // ).to.equal(additionalPayouts.add(offeredItem.endAmount).toString()); + // } + // } + + // if (offeredItem.itemType === 2) { + // // ERC721 + // expect(offeredItem.ownsItemBefore).to.equal(true); + // expect(offeredItem.ownsItemAfter).to.equal(false); + // } + // } + + // This doesn't aggregate items of the same kind and recipient + // for (const receivedItem of allReceivedItems as any[]) { + // const duration = toBN(receivedItem.endTime).sub(receivedItem.startTime); + // const elapsed = toBN(timestamp).sub(receivedItem.startTime); + // const remaining = duration.sub(elapsed); + + // expect( + // receivedItem.finalBalance.sub(receivedItem.initialBalance).toString() + // ).to.equal( + // toBN(receivedItem.startAmount) + // .mul(remaining) + // .add(toBN(receivedItem.endAmount).mul(elapsed)) + // .add(duration.sub(1)) + // .div(duration) + // .mul(receivedItem.numerator) + // .div(receivedItem.denominator) + // .mul(multiplier) + // .toString() + // ); + + // if (receivedItem.itemType === 2) { + // // ERC721 + // expect(receivedItem.ownsItemBefore).to.equal(false); + // expect(receivedItem.ownsItemAfter).to.equal(true); + // } + // } + + return receipt; + }; + + const checkTransferEvent = async ( + tx: any, + item: any, + { offerer, conduitKey, target }: any + ) => { + const { + itemType, + token, + identifier: id1, + identifierOrCriteria: id2, + amount, + recipient, + } = item; + const identifier = id1 || id2; + const sender = getTransferSender(offerer, conduitKey); + + if ([1, 2, 5].includes(itemType)) { + const contract = new Contract( + token, + (itemType === 1 ? testERC20 : testERC721).interface, + provider + ); + await expect(tx) + .to.emit(contract, "Transfer") + .withArgs(offerer, recipient, itemType === 1 ? amount : identifier); + } else if ([3, 4].includes(itemType)) { + const contract = new Contract(token, testERC1155.interface, provider); + const operator = sender !== offerer ? sender : target; + + await expect(tx) + .to.emit(contract, "TransferSingle") + .withArgs(operator, offerer, recipient, identifier, amount); + } + }; + + const checkExpectedEvents = async ( + tx: Promise, + receipt: ContractReceipt, + orderGroups: Array<{ + order: AdvancedOrder; + orderHash: string; + fulfiller?: string; + fulfillerConduitKey?: string; + recipient?: string; + }>, + standardExecutions: any[] = [], + criteriaResolvers: any[] = [], + shouldSkipAmountComparison = false, + multiplier = 1 + ) => { + const { timestamp } = await provider.getBlock(receipt.blockHash); + + if (standardExecutions && standardExecutions.length) { + for (const standardExecution of standardExecutions) { + const { item, offerer, conduitKey, operator } = standardExecution; + + await checkTransferEvent(tx, item, { + offerer, + conduitKey, + target: operator ?? receipt.to, + }); + } + + // TODO: sum up executions and compare to orders to ensure that all the + // items (or partially-filled items) are accounted for + } + + if (criteriaResolvers && criteriaResolvers.length) { + for (const { orderIndex, side, index, identifier } of criteriaResolvers) { + const itemType = + orderGroups[orderIndex].order.parameters[ + side === 0 ? "offer" : "consideration" + ][index].itemType; + if (itemType < 4) { + console.error("APPLYING CRITERIA TO NON-CRITERIA-BASED ITEM"); + process.exit(1); + } + + orderGroups[orderIndex].order.parameters[ + side === 0 ? "offer" : "consideration" + ][index].itemType = itemType - 2; + orderGroups[orderIndex].order.parameters[ + side === 0 ? "offer" : "consideration" + ][index].identifierOrCriteria = identifier; + } + } + + for (let { + order, + orderHash, + fulfiller, + fulfillerConduitKey, + recipient, + } of orderGroups) { + if (!recipient) { + recipient = fulfiller; + } + const duration = toBN(order.parameters.endTime).sub( + order.parameters.startTime as any + ); + const elapsed = toBN(timestamp).sub(order.parameters.startTime as any); + const remaining = duration.sub(elapsed); + + const marketplaceContractEvents = (receipt.events as any[]) + .filter((x) => { + try { + marketplaceContract.interface.parseLog({ + data: x.data, + topics: x.topics, + }); + return true; + } catch (e) { + return false; + } + }) + .map((x) => { + const { args, name, signature } = + marketplaceContract.interface.parseLog({ + data: x.data, + topics: x.topics, + }); + + return { + eventName: name, + eventSignature: signature, + orderHash: args.orderHash, + offerer: args.offerer, + zone: args.zone, + recipient: args.recipient, + offer: args.offer.map((y: any) => ({ + itemType: y.itemType, + token: y.token, + identifier: y.identifier, + amount: y.amount, + })), + consideration: args.consideration.map((y: any) => ({ + itemType: y.itemType, + token: y.token, + identifier: y.identifier, + amount: y.amount, + recipient: y.recipient, + })), + }; + }) + .filter((x) => x.orderHash === orderHash); + + expect(marketplaceContractEvents.length).to.equal(1); + + const event = marketplaceContractEvents[0]; + + expect(event.eventName).to.equal("OrderFulfilled"); + expect(event.eventSignature).to.equal( + "OrderFulfilled(" + + "bytes32,address,address,address,(" + + "uint8,address,uint256,uint256)[],(" + + "uint8,address,uint256,uint256,address)[])" + ); + expect(event.orderHash).to.equal(orderHash); + expect(event.offerer).to.equal(order.parameters.offerer); + expect(event.zone).to.equal(order.parameters.zone); + expect(event.recipient).to.equal(recipient); + + const { offerer, conduitKey, consideration, offer } = order.parameters; + const compareEventItems = async ( + item: any, + orderItem: any, + isConsiderationItem: boolean + ) => { + expect(item.itemType).to.equal( + orderItem.itemType > 3 ? orderItem.itemType - 2 : orderItem.itemType + ); + expect(item.token).to.equal(orderItem.token); + // expect(item.token).to.equal(tokenByType[item.itemType].address); + if (orderItem.itemType < 4) { + // no criteria-based + expect(item.identifier).to.equal(orderItem.identifierOrCriteria); + } else { + console.error("CRITERIA-BASED EVENT VALIDATION NOT MET"); + process.exit(1); + } + + if (order.parameters.orderType === 0) { + // FULL_OPEN (no partial fills) + if ( + orderItem.startAmount.toString() === orderItem.endAmount.toString() + ) { + expect(item.amount.toString()).to.equal( + orderItem.endAmount.toString() + ); + } else { + expect(item.amount.toString()).to.equal( + toBN(orderItem.startAmount) + .mul(remaining) + .add(toBN(orderItem.endAmount).mul(elapsed)) + .add(isConsiderationItem ? duration.sub(1) : 0) + .div(duration) + .toString() + ); + } + } else { + if ( + orderItem.startAmount.toString() === orderItem.endAmount.toString() + ) { + expect(item.amount.toString()).to.equal( + orderItem.endAmount + .mul(order.numerator) + .div(order.denominator) + .toString() + ); + } else { + console.error("SLIDING AMOUNT NOT IMPLEMENTED YET"); + process.exit(1); + } + } + }; + + if (!standardExecutions || !standardExecutions.length) { + for (const item of consideration) { + const { startAmount, endAmount } = item; + let amount; + if (order.parameters.orderType === 0) { + amount = startAmount.eq(endAmount) + ? endAmount + : startAmount + .mul(remaining) + .add(endAmount.mul(elapsed)) + .add(duration.sub(1)) + .div(duration); + } else { + amount = endAmount.mul(order.numerator).div(order.denominator); + } + amount = amount.mul(multiplier); + + await checkTransferEvent( + tx, + { ...item, amount }, + { + offerer: receipt.from, + conduitKey: fulfillerConduitKey, + target: receipt.to, + } + ); + } + + for (const item of offer) { + const { startAmount, endAmount } = item; + let amount; + if (order.parameters.orderType === 0) { + amount = startAmount.eq(endAmount) + ? endAmount + : startAmount + .mul(remaining) + .add(endAmount.mul(elapsed)) + .div(duration); + } else { + amount = endAmount.mul(order.numerator).div(order.denominator); + } + amount = amount.mul(multiplier); + + await checkTransferEvent( + tx, + { ...item, amount, recipient }, + { + offerer, + conduitKey, + target: marketplaceContract.address, // TODO: could be zone too + } + ); + } + } + + expect(event.offer.length).to.equal(order.parameters.offer.length); + for (const [index, offer] of Object.entries(event.offer) as any[]) { + const offerItem = order.parameters.offer[index]; + await compareEventItems(offer, offerItem, false); + + const tokenEvents = receipt.events?.filter( + (x) => x.address === offerItem.token + ); + + if (offer.itemType === 1) { + // ERC20 + // search for transfer + const transferLogs = (tokenEvents || []) + .map((x) => { + try { + return testERC20.interface.parseLog(x); + } catch (e) { + return null; + } + }) + .filter( + (x) => + x && + x.signature === "Transfer(address,address,uint256)" && + x.args.from === event.offerer && + (recipient !== constants.AddressZero + ? x.args.to === recipient + : true) + ); + + expect(transferLogs.length).to.be.above(0); + for (const transferLog of transferLogs) { + // TODO: check each transferred amount + } + } else if (offer.itemType === 2) { + // ERC721 + // search for transfer + const transferLogs = (tokenEvents || []) + .map((x) => testERC721.interface.parseLog(x)) + .filter( + (x) => + x.signature === "Transfer(address,address,uint256)" && + x.args.from === event.offerer && + (recipient !== constants.AddressZero + ? x.args.to === recipient + : true) + ); + + expect(transferLogs.length).to.equal(1); + const transferLog = transferLogs[0]; + expect(transferLog.args.id.toString()).to.equal( + offer.identifier.toString() + ); + } else if (offer.itemType === 3) { + // search for transfer + const transferLogs = (tokenEvents || []) + .map((x) => testERC1155.interface.parseLog(x)) + .filter( + (x) => + (x.signature === + "TransferSingle(address,address,address,uint256,uint256)" && + x.args.from === event.offerer && + (fulfiller !== constants.AddressZero + ? x.args.to === fulfiller + : true)) || + (x.signature === + "TransferBatch(address,address,address,uint256[],uint256[])" && + x.args.from === event.offerer && + (fulfiller !== constants.AddressZero + ? x.args.to === fulfiller + : true)) + ); + + expect(transferLogs.length > 0).to.be.true; + + let found = false; + for (const transferLog of transferLogs) { + if ( + transferLog.signature === + "TransferSingle(address,address,address,uint256,uint256)" && + transferLog.args.id.toString() === offer.identifier.toString() && + (shouldSkipAmountComparison || + transferLog.args.amount.toString() === + offer.amount.mul(multiplier).toString()) + ) { + found = true; + break; + } + } + + expect(found).to.be.true; + } + } + + expect(event.consideration.length).to.equal( + order.parameters.consideration.length + ); + for (const [index, consideration] of Object.entries( + event.consideration + ) as any[]) { + const considerationItem = order.parameters.consideration[index]; + await compareEventItems(consideration, considerationItem, true); + expect(consideration.recipient).to.equal(considerationItem.recipient); + + const tokenEvents = receipt.events?.filter( + (x) => x.address === considerationItem.token + ); + + if (consideration.itemType === 1) { + // ERC20 + // search for transfer + const transferLogs = (tokenEvents || []) + .map((x) => { + try { + return testERC20.interface.parseLog(x); + } catch (e) { + return null; + } + }) + .filter( + (x) => + x && + x.signature === "Transfer(address,address,uint256)" && + x.args.to === consideration.recipient + ); + + expect(transferLogs.length).to.be.above(0); + for (const transferLog of transferLogs) { + // TODO: check each transferred amount + } + } else if (consideration.itemType === 2) { + // ERC721 + // search for transfer + + const transferLogs = (tokenEvents || []) + .map((x) => testERC721.interface.parseLog(x)) + .filter( + (x) => + x.signature === "Transfer(address,address,uint256)" && + x.args.to === consideration.recipient + ); + + expect(transferLogs.length).to.equal(1); + const transferLog = transferLogs[0]; + expect(transferLog.args.id.toString()).to.equal( + consideration.identifier.toString() + ); + } else if (consideration.itemType === 3) { + // search for transfer + const transferLogs = (tokenEvents || []) + .map((x) => testERC1155.interface.parseLog(x)) + .filter( + (x) => + (x.signature === + "TransferSingle(address,address,address,uint256,uint256)" && + x.args.to === consideration.recipient) || + (x.signature === + "TransferBatch(address,address,address,uint256[],uint256[])" && + x.args.to === consideration.recipient) + ); + + expect(transferLogs.length > 0).to.be.true; + + let found = false; + for (const transferLog of transferLogs) { + if ( + transferLog.signature === + "TransferSingle(address,address,address,uint256,uint256)" && + transferLog.args.id.toString() === + consideration.identifier.toString() && + (shouldSkipAmountComparison || + transferLog.args.amount.toString() === + consideration.amount.mul(multiplier).toString()) + ) { + found = true; + break; + } + } + + expect(found).to.be.true; + } + } + } + }; + + return { + EIP1271WalletFactory, + reenterer, + chainId, + conduitController, + conduitImplementation, + conduitKeyOne, + conduitOne, + getTransferSender, + deployNewConduit, + testERC20, + mintAndApproveERC20, + getTestItem20, + testERC721, + set721ApprovalForAll, + mint721, + mint721s, + mintAndApprove721, + getTestItem721, + getTestItem721WithCriteria, + testERC1155, + set1155ApprovalForAll, + mint1155, + mintAndApprove1155, + getTestItem1155WithCriteria, + getTestItem1155, + testERC1155Two, + tokenByType, + createTransferWithApproval, + marketplaceContract, + directMarketplaceContract, + stubZone, + domainData, + signOrder, + createOrder, + createMirrorBuyNowOrder, + createMirrorAcceptOfferOrder, + withBalanceChecks, + checkTransferEvent, + checkExpectedEvents, + }; +}; + +export type SeaportFixtures = Awaited>; diff --git a/test/utils/fixtures/marketplace.ts b/test/utils/fixtures/marketplace.ts new file mode 100644 index 00000000..fa1527b7 --- /dev/null +++ b/test/utils/fixtures/marketplace.ts @@ -0,0 +1,476 @@ +import { expect } from "chai"; +import { constants, Wallet } from "ethers"; +import { keccak256, recoverAddress } from "ethers/lib/utils"; +import hre, { ethers } from "hardhat"; +import { + ConduitInterface, + ConduitControllerInterface, + ImmutableCreate2FactoryInterface, + ConsiderationInterface, + TestZone, +} from "../../../typechain-types"; +import { deployContract } from "../contracts"; +import { + calculateOrderHash, + convertSignatureToEIP2098, + randomHex, + toBN, +} from "../encoding"; +import { + AdvancedOrder, + ConsiderationItem, + CriteriaResolver, + OfferItem, + OrderComponents, +} from "../types"; + +const { orderType } = require("../../../eip-712-types/order"); +const deployConstants = require("../../../constants/constants"); + +const VERSION = !process.env.REFERENCE ? "1.1" : "rc.1.1"; + +export const marketplaceFixture = async ( + create2Factory: ImmutableCreate2FactoryInterface, + conduitController: ConduitControllerInterface, + conduitOne: ConduitInterface, + chainId: number, + owner: Wallet +) => { + // Deploy marketplace contract through efficient create2 factory + const marketplaceContractFactory = await ethers.getContractFactory( + process.env.REFERENCE ? "ReferenceConsideration" : "Seaport" + ); + + const directMarketplaceContract = await deployContract( + process.env.REFERENCE ? "ReferenceConsideration" : "Consideration", + owner as any, + conduitController.address + ); + + const marketplaceContractAddress = await create2Factory.findCreate2Address( + deployConstants.MARKETPLACE_CONTRACT_CREATION_SALT, + marketplaceContractFactory.bytecode + + conduitController.address.slice(2).padStart(64, "0") + ); + + let { gasLimit } = await ethers.provider.getBlock("latest"); + + if ((hre as any).__SOLIDITY_COVERAGE_RUNNING) { + gasLimit = ethers.BigNumber.from(300_000_000); + } + + await create2Factory.safeCreate2( + deployConstants.MARKETPLACE_CONTRACT_CREATION_SALT, + marketplaceContractFactory.bytecode + + conduitController.address.slice(2).padStart(64, "0"), + { + gasLimit, + } + ); + + const marketplaceContract = (await ethers.getContractAt( + process.env.REFERENCE ? "ReferenceConsideration" : "Seaport", + marketplaceContractAddress, + owner + )) as ConsiderationInterface; + + await conduitController + .connect(owner) + .updateChannel(conduitOne.address, marketplaceContract.address, true); + + const stubZone: TestZone = await deployContract("TestZone", owner as any); + + // Required for EIP712 signing + const domainData = { + name: process.env.REFERENCE ? "Consideration" : "Seaport", + version: VERSION, + chainId: chainId, + verifyingContract: marketplaceContract.address, + }; + + const getAndVerifyOrderHash = async (orderComponents: OrderComponents) => { + const orderHash = await marketplaceContract.getOrderHash( + orderComponents as any + ); + const derivedOrderHash = calculateOrderHash(orderComponents); + expect(orderHash).to.equal(derivedOrderHash); + return orderHash; + }; + + // Returns signature + const signOrder = async ( + orderComponents: OrderComponents, + signer: Wallet + ) => { + const signature = await signer._signTypedData( + domainData, + orderType, + orderComponents + ); + + const orderHash = await getAndVerifyOrderHash(orderComponents); + + const { domainSeparator } = await marketplaceContract.information(); + const digest = keccak256( + `0x1901${domainSeparator.slice(2)}${orderHash.slice(2)}` + ); + const recoveredAddress = recoverAddress(digest, signature); + + expect(recoveredAddress).to.equal(signer.address); + + return signature; + }; + + const createOrder = async ( + offerer: Wallet, + zone: Wallet | undefined | string = undefined, + offer: OfferItem[], + consideration: ConsiderationItem[], + orderType: number, + criteriaResolvers?: CriteriaResolver[], + timeFlag?: string | null, + signer?: Wallet, + zoneHash = constants.HashZero, + conduitKey = constants.HashZero, + extraCheap = false + ) => { + const counter = await marketplaceContract.getCounter(offerer.address); + + const salt = !extraCheap ? randomHex() : constants.HashZero; + const startTime = + timeFlag !== "NOT_STARTED" ? 0 : toBN("0xee00000000000000000000000000"); + const endTime = + timeFlag !== "EXPIRED" ? toBN("0xff00000000000000000000000000") : 1; + + const orderParameters = { + offerer: offerer.address, + zone: !extraCheap + ? (zone as Wallet).address || (zone as string) + : constants.AddressZero, + offer, + consideration, + totalOriginalConsiderationItems: consideration.length, + orderType, + zoneHash, + salt, + conduitKey, + startTime, + endTime, + }; + + const orderComponents = { + ...orderParameters, + counter, + }; + + const orderHash = await getAndVerifyOrderHash(orderComponents); + + const { isValidated, isCancelled, totalFilled, totalSize } = + await marketplaceContract.getOrderStatus(orderHash); + + expect(isCancelled).to.equal(false); + + const orderStatus = { + isValidated, + isCancelled, + totalFilled, + totalSize, + }; + + const flatSig = await signOrder(orderComponents, signer || offerer); + + const order = { + parameters: orderParameters, + signature: !extraCheap ? flatSig : convertSignatureToEIP2098(flatSig), + numerator: 1, // only used for advanced orders + denominator: 1, // only used for advanced orders + extraData: "0x", // only used for advanced orders + }; + + // How much ether (at most) needs to be supplied when fulfilling the order + const value = offer + .map((x) => + x.itemType === 0 + ? x.endAmount.gt(x.startAmount) + ? x.endAmount + : x.startAmount + : toBN(0) + ) + .reduce((a, b) => a.add(b), toBN(0)) + .add( + consideration + .map((x) => + x.itemType === 0 + ? x.endAmount.gt(x.startAmount) + ? x.endAmount + : x.startAmount + : toBN(0) + ) + .reduce((a, b) => a.add(b), toBN(0)) + ); + + return { + order, + orderHash, + value, + orderStatus, + orderComponents, + }; + }; + + const createMirrorBuyNowOrder = async ( + offerer: Wallet, + zone: Wallet, + order: AdvancedOrder, + conduitKey = constants.HashZero + ) => { + const counter = await marketplaceContract.getCounter(offerer.address); + const salt = randomHex(); + const startTime = order.parameters.startTime; + const endTime = order.parameters.endTime; + + const compressedOfferItems = []; + for (const { + itemType, + token, + identifierOrCriteria, + startAmount, + endAmount, + } of order.parameters.offer) { + if ( + !compressedOfferItems + .map((x) => `${x.itemType}+${x.token}+${x.identifierOrCriteria}`) + .includes(`${itemType}+${token}+${identifierOrCriteria}`) + ) { + compressedOfferItems.push({ + itemType, + token, + identifierOrCriteria, + startAmount: startAmount.eq(endAmount) + ? startAmount + : startAmount.sub(1), + endAmount: startAmount.eq(endAmount) ? endAmount : endAmount.sub(1), + }); + } else { + const index = compressedOfferItems + .map((x) => `${x.itemType}+${x.token}+${x.identifierOrCriteria}`) + .indexOf(`${itemType}+${token}+${identifierOrCriteria}`); + + compressedOfferItems[index].startAmount = compressedOfferItems[ + index + ].startAmount.add( + startAmount.eq(endAmount) ? startAmount : startAmount.sub(1) + ); + compressedOfferItems[index].endAmount = compressedOfferItems[ + index + ].endAmount.add( + startAmount.eq(endAmount) ? endAmount : endAmount.sub(1) + ); + } + } + + const compressedConsiderationItems = []; + for (const { + itemType, + token, + identifierOrCriteria, + startAmount, + endAmount, + recipient, + } of order.parameters.consideration) { + if ( + !compressedConsiderationItems + .map((x) => `${x.itemType}+${x.token}+${x.identifierOrCriteria}`) + .includes(`${itemType}+${token}+${identifierOrCriteria}`) + ) { + compressedConsiderationItems.push({ + itemType, + token, + identifierOrCriteria, + startAmount: startAmount.eq(endAmount) + ? startAmount + : startAmount.add(1), + endAmount: startAmount.eq(endAmount) ? endAmount : endAmount.add(1), + recipient, + }); + } else { + const index = compressedConsiderationItems + .map((x) => `${x.itemType}+${x.token}+${x.identifierOrCriteria}`) + .indexOf(`${itemType}+${token}+${identifierOrCriteria}`); + + compressedConsiderationItems[index].startAmount = + compressedConsiderationItems[index].startAmount.add( + startAmount.eq(endAmount) ? startAmount : startAmount.add(1) + ); + compressedConsiderationItems[index].endAmount = + compressedConsiderationItems[index].endAmount.add( + startAmount.eq(endAmount) ? endAmount : endAmount.add(1) + ); + } + } + + const orderParameters = { + offerer: offerer.address, + zone: zone.address, + offer: compressedConsiderationItems.map((x) => ({ ...x })), + consideration: compressedOfferItems.map((x) => ({ + ...x, + recipient: offerer.address, + })), + totalOriginalConsiderationItems: compressedOfferItems.length, + orderType: order.parameters.orderType, // FULL_OPEN + zoneHash: "0x".padEnd(66, "0"), + salt, + conduitKey, + startTime, + endTime, + }; + + const orderComponents = { + ...orderParameters, + counter, + }; + + const flatSig = await signOrder(orderComponents, offerer); + + const mirrorOrderHash = await getAndVerifyOrderHash(orderComponents); + + const mirrorOrder = { + parameters: orderParameters, + signature: flatSig, + numerator: order.numerator, // only used for advanced orders + denominator: order.denominator, // only used for advanced orders + extraData: "0x", // only used for advanced orders + }; + + // How much ether (at most) needs to be supplied when fulfilling the order + const mirrorValue = orderParameters.consideration + .map((x) => + x.itemType === 0 + ? x.endAmount.gt(x.startAmount) + ? x.endAmount + : x.startAmount + : toBN(0) + ) + .reduce((a, b) => a.add(b), toBN(0)); + + return { + mirrorOrder, + mirrorOrderHash, + mirrorValue, + }; + }; + + const createMirrorAcceptOfferOrder = async ( + offerer: Wallet, + zone: Wallet, + order: AdvancedOrder, + criteriaResolvers: CriteriaResolver[] = [], + conduitKey = constants.HashZero + ) => { + const counter = await marketplaceContract.getCounter(offerer.address); + const salt = randomHex(); + const startTime = order.parameters.startTime; + const endTime = order.parameters.endTime; + + const orderParameters = { + offerer: offerer.address, + zone: zone.address, + offer: order.parameters.consideration + .filter((x) => x.itemType !== 1) + .map((x) => ({ + itemType: x.itemType < 4 ? x.itemType : x.itemType - 2, + token: x.token, + identifierOrCriteria: + x.itemType < 4 + ? x.identifierOrCriteria + : criteriaResolvers[0].identifier, + startAmount: x.startAmount, + endAmount: x.endAmount, + })), + consideration: order.parameters.offer.map((x) => ({ + itemType: x.itemType < 4 ? x.itemType : x.itemType - 2, + token: x.token, + identifierOrCriteria: + x.itemType < 4 + ? x.identifierOrCriteria + : criteriaResolvers[0].identifier, + recipient: offerer.address, + startAmount: toBN(x.endAmount).sub( + order.parameters.consideration + .filter( + (i) => + i.itemType < 2 && + i.itemType === x.itemType && + i.token === x.token + ) + .map((i) => i.endAmount) + .reduce((a, b) => a.add(b), toBN(0)) + ), + endAmount: toBN(x.endAmount).sub( + order.parameters.consideration + .filter( + (i) => + i.itemType < 2 && + i.itemType === x.itemType && + i.token === x.token + ) + .map((i) => i.endAmount) + .reduce((a, b) => a.add(b), toBN(0)) + ), + })), + totalOriginalConsiderationItems: order.parameters.offer.length, + orderType: 0, // FULL_OPEN + zoneHash: constants.HashZero, + salt, + conduitKey, + startTime, + endTime, + }; + + const orderComponents = { + ...orderParameters, + counter, + }; + + const flatSig = await signOrder(orderComponents as any, offerer); + + const mirrorOrderHash = await getAndVerifyOrderHash(orderComponents as any); + + const mirrorOrder = { + parameters: orderParameters, + signature: flatSig, + numerator: 1, // only used for advanced orders + denominator: 1, // only used for advanced orders + extraData: "0x", // only used for advanced orders + }; + + // How much ether (at most) needs to be supplied when fulfilling the order + const mirrorValue = orderParameters.consideration + .map((x) => + x.itemType === 0 + ? x.endAmount.gt(x.startAmount) + ? x.endAmount + : x.startAmount + : toBN(0) + ) + .reduce((a, b) => a.add(b), toBN(0)); + + return { + mirrorOrder, + mirrorOrderHash, + mirrorValue, + }; + }; + + return { + marketplaceContract, + directMarketplaceContract, + stubZone, + domainData, + signOrder, + createOrder, + createMirrorBuyNowOrder, + createMirrorAcceptOfferOrder, + }; +}; diff --git a/test/utils/fixtures/seedSushiswapPools.ts b/test/utils/fixtures/seedSushiswapPools.ts new file mode 100644 index 00000000..7c94f81c --- /dev/null +++ b/test/utils/fixtures/seedSushiswapPools.ts @@ -0,0 +1,69 @@ +import { ethers, deployments } from "hardhat"; +import { BigNumberish, Contract, Signer } from "ethers"; +import { HardhatRuntimeEnvironment } from "hardhat/types"; + +async function transfer( + signer: Signer & { address: string }, + token: Contract, + amount: BigNumberish +) { + const WETH = await ethers.getContract("TestWETH"); + if (token.address === WETH.address) { + await token.connect(signer).deposit({ value: amount }); + } else { + await token.mint(signer.address, amount); + } +} + +interface Pair { + token0: Contract; + token0Amount: BigNumberish; + token1: Contract; + token1Amount: BigNumberish; +} + +export const seedSushiswapPools = deployments.createFixture( + async ( + { + deployments, + ethers: { + getNamedSigners, + constants: { MaxUint256 }, + }, + }: HardhatRuntimeEnvironment, + options: { pairs: Pair[] } | undefined + ) => { + if (!options) return; + + const { pairs } = options; + + const { deployer } = await getNamedSigners(); + + const sushiswapRouter = await ethers.getContract("UniswapV2Router02"); + + for (let i = 0; i < pairs.length; i++) { + await transfer(deployer, pairs[i].token0, pairs[i].token0Amount); + await transfer(deployer, pairs[i].token1, pairs[i].token1Amount); + + await pairs[i].token0 + .connect(deployer) + .approve(sushiswapRouter.address, MaxUint256); + await pairs[i].token1 + .connect(deployer) + .approve(sushiswapRouter.address, MaxUint256); + + await sushiswapRouter + .connect(deployer) + .addLiquidity( + pairs[i].token0.address, + pairs[i].token1.address, + pairs[i].token0Amount, + pairs[i].token1Amount, + 0, + 0, + deployer.address, + MaxUint256 + ); + } + } +); diff --git a/test/utils/fixtures/shoyuFixture.ts b/test/utils/fixtures/shoyuFixture.ts new file mode 100644 index 00000000..797b9c5d --- /dev/null +++ b/test/utils/fixtures/shoyuFixture.ts @@ -0,0 +1,71 @@ +import { Contract, Signer } from "ethers"; +import { MaxUint256 } from "@ethersproject/constants"; +import { deployments, ethers, upgrades } from "hardhat"; +import { deployContract } from "../contracts"; + +export const shoyuFixture = async ( + owner: Signer, + seaport: Contract, + conduitController: Contract +) => { + await deployments.fixture("DeploySushiswap"); + + const testWETH = await ethers.getContract("TestWETH"); + + const sushiswapFactory = await ethers.getContract("UniswapV2Factory"); + + const bentobox = await ethers.getContract("BentoBoxV1"); + + const pairCodeHash = await sushiswapFactory.pairCodeHash(); + + const transformationAdapter = await deployContract( + "TransformationAdapter", + owner as any, + testWETH.address, + sushiswapFactory.address, + pairCodeHash, + conduitController.address, + bentobox.address + ); + + const seaportAdapter = await deployContract( + "SeaportAdapter", + owner as any, + seaport.address + ); + + const adapterRegistry = await deployContract( + "AdapterRegistry", + owner as any, + 2, + [transformationAdapter.address, seaportAdapter.address], + [true, true] + ); + + const shoyuFactory = await ethers.getContractFactory("Shoyu"); + + const shoyuContract = await upgrades.deployProxy( + shoyuFactory, + [adapterRegistry.address, bentobox.address], + { + initializer: "initialize", + unsafeAllow: ["delegatecall"], + } + ); + + await shoyuContract.deployed(); + + await shoyuContract.approveERC20( + testWETH.address, + seaport.address, + MaxUint256 + ); + + return { + shoyuContract, + testWETH, + transformationAdapter, + seaportAdapter, + bentobox, + }; +}; diff --git a/test/utils/fixtures/tokens.ts b/test/utils/fixtures/tokens.ts new file mode 100644 index 00000000..9fddd437 --- /dev/null +++ b/test/utils/fixtures/tokens.ts @@ -0,0 +1,301 @@ +/* eslint-disable camelcase */ +import { JsonRpcSigner } from "@ethersproject/providers"; +import { expect } from "chai"; +import { BigNumber, constants, Wallet } from "ethers"; +import { ethers } from "hardhat"; +import { TestERC1155, TestERC20, TestERC721 } from "../../../typechain-types"; +import { deployContract } from "../contracts"; +import { + randomBN, + toBN, + BigNumberish, + getOfferOrConsiderationItem, + random128, +} from "../encoding"; +import { whileImpersonating } from "../impersonate"; + +export const fixtureERC20 = async (signer: JsonRpcSigner) => { + const testERC20: TestERC20 = await deployContract("TestERC20", signer); + + const mintAndApproveERC20 = async ( + signer: Wallet, + spender: string, + tokenAmount: BigNumberish + ) => { + const amount = toBN(tokenAmount); + // Offerer mints ERC20 + await testERC20.mint(signer.address, amount); + + // Offerer approves marketplace contract to tokens + await expect(testERC20.connect(signer).approve(spender, amount)) + .to.emit(testERC20, "Approval") + .withArgs(signer.address, spender, tokenAmount); + }; + + const getTestItem20 = ( + startAmount: BigNumberish = 50, + endAmount: BigNumberish = 50, + recipient?: string, + token = testERC20.address + ) => + getOfferOrConsiderationItem(1, token, 0, startAmount, endAmount, recipient); + + return { + testERC20, + mintAndApproveERC20, + getTestItem20, + }; +}; + +export const fixtureERC721 = async (signer: JsonRpcSigner) => { + const testERC721: TestERC721 = await deployContract("TestERC721", signer); + + const set721ApprovalForAll = ( + signer: Wallet, + spender: string, + approved = true, + contract = testERC721 + ) => { + return expect(contract.connect(signer).setApprovalForAll(spender, approved)) + .to.emit(contract, "ApprovalForAll") + .withArgs(signer.address, spender, approved); + }; + + const mint721 = async (signer: Wallet, id?: BigNumberish) => { + const nftId = id ? toBN(id) : randomBN(); + await testERC721.mint(signer.address, nftId); + return nftId; + }; + + const mint721s = async (signer: Wallet, count: number) => { + const arr = []; + for (let i = 0; i < count; i++) arr.push(await mint721(signer)); + return arr; + }; + + const mintAndApprove721 = async ( + signer: Wallet, + spender: string, + id?: BigNumberish + ) => { + await set721ApprovalForAll(signer, spender, true); + return mint721(signer, id); + }; + + const getTestItem721 = ( + identifierOrCriteria: BigNumberish, + startAmount: BigNumberish = 1, + endAmount: BigNumberish = 1, + recipient?: string, + token = testERC721.address + ) => + getOfferOrConsiderationItem( + 2, + token, + identifierOrCriteria, + startAmount, + endAmount, + recipient + ); + + const getTestItem721WithCriteria = ( + identifierOrCriteria: BigNumberish, + startAmount: BigNumberish = 1, + endAmount: BigNumberish = 1, + recipient?: string + ) => + getOfferOrConsiderationItem( + 4, + testERC721.address, + identifierOrCriteria, + startAmount, + endAmount, + recipient + ); + + return { + testERC721, + set721ApprovalForAll, + mint721, + mint721s, + mintAndApprove721, + getTestItem721, + getTestItem721WithCriteria, + }; +}; + +export const fixtureERC1155 = async (signer: JsonRpcSigner) => { + const testERC1155: TestERC1155 = await deployContract("TestERC1155", signer); + + const set1155ApprovalForAll = ( + signer: Wallet, + spender: string, + approved = true, + token = testERC1155 + ) => { + return expect(token.connect(signer).setApprovalForAll(spender, approved)) + .to.emit(token, "ApprovalForAll") + .withArgs(signer.address, spender, approved); + }; + + const mint1155 = async ( + signer: Wallet, + multiplier = 1, + token = testERC1155, + id?: BigNumberish, + amt?: BigNumberish + ) => { + const nftId = id ? toBN(id) : randomBN(); + const amount = amt ? toBN(amt) : toBN(randomBN(4)); + await token.mint(signer.address, nftId, amount.mul(multiplier)); + return { nftId, amount }; + }; + + const mintAndApprove1155 = async ( + signer: Wallet, + spender: string, + multiplier = 1, + id?: BigNumberish, + amt?: BigNumberish + ) => { + const { nftId, amount } = await mint1155( + signer, + multiplier, + testERC1155, + id, + amt + ); + await set1155ApprovalForAll(signer, spender, true); + return { nftId, amount }; + }; + + const getTestItem1155WithCriteria = ( + identifierOrCriteria: BigNumberish, + startAmount: BigNumberish = 1, + endAmount: BigNumberish = 1, + recipient?: string + ) => + getOfferOrConsiderationItem( + 5, + testERC1155.address, + identifierOrCriteria, + startAmount, + endAmount, + recipient + ); + + const getTestItem1155 = ( + identifierOrCriteria: BigNumberish, + startAmount: BigNumberish, + endAmount: BigNumberish, + token = testERC1155.address, + recipient?: string + ) => + getOfferOrConsiderationItem( + 3, + token, + identifierOrCriteria, + startAmount, + endAmount, + recipient + ); + + return { + testERC1155, + set1155ApprovalForAll, + mint1155, + mintAndApprove1155, + getTestItem1155WithCriteria, + getTestItem1155, + }; +}; + +const minRandom = (min: number) => randomBN(10).add(min); + +export const tokensFixture = async (signer: JsonRpcSigner) => { + const erc20 = await fixtureERC20(signer); + const erc721 = await fixtureERC721(signer); + const erc1155 = await fixtureERC1155(signer); + const { testERC1155: testERC1155Two } = await fixtureERC1155(signer); + const tokenByType = [ + { + address: constants.AddressZero, + } as any, // ETH + erc20.testERC20, + erc721.testERC721, + erc1155.testERC1155, + ]; + const createTransferWithApproval = async ( + contract: TestERC20 | TestERC1155 | TestERC721, + receiver: Wallet, + itemType: 0 | 1 | 2 | 3 | 4 | 5, + approvalAddress: string, + from: string, + to: string + ) => { + let identifier: BigNumber = toBN(0); + let amount: BigNumber = toBN(0); + const token = contract.address; + + switch (itemType) { + case 0: + break; + case 1: // ERC20 + amount = minRandom(100); + await (contract as TestERC20).mint(receiver.address, amount); + + // Receiver approves contract to transfer tokens + await whileImpersonating( + receiver.address, + ethers.provider, + async () => { + await expect( + (contract as TestERC20) + .connect(receiver) + .approve(approvalAddress, amount) + ) + .to.emit(contract, "Approval") + .withArgs(receiver.address, approvalAddress, amount); + } + ); + break; + case 2: // ERC721 + case 4: // ERC721_WITH_CRITERIA + amount = toBN(1); + identifier = randomBN(); + await (contract as TestERC721).mint(receiver.address, identifier); + + // Receiver approves contract to transfer tokens + await erc721.set721ApprovalForAll( + receiver, + approvalAddress, + true, + contract as TestERC721 + ); + break; + case 3: // ERC1155 + case 5: // ERC1155_WITH_CRITERIA + identifier = random128(); + amount = minRandom(1); + await contract.mint(receiver.address, identifier, amount); + + // Receiver approves contract to transfer tokens + await erc1155.set1155ApprovalForAll( + receiver, + approvalAddress, + true, + contract as TestERC1155 + ); + break; + } + return { itemType, token, from, to, identifier, amount }; + }; + return { + ...erc20, + ...erc721, + ...erc1155, + testERC1155Two, + tokenByType, + createTransferWithApproval, + }; +}; diff --git a/test/utils/helpers.ts b/test/utils/helpers.ts new file mode 100644 index 00000000..e137c295 --- /dev/null +++ b/test/utils/helpers.ts @@ -0,0 +1,38 @@ +import { splitSignature } from "@ethersproject/bytes"; +import { Contract } from "@ethersproject/contracts"; +import { Wallet } from "@ethersproject/wallet"; + +export async function signBentoMasterContractApproval( + bentobox: Contract, + user: Wallet, + contractToApprove: string, + approved = true +) { + const nonces = await bentobox.nonces(user.address); + + const signature = await user._signTypedData( + { + name: "BentoBox V1", + chainId: 31337, + verifyingContract: bentobox.address, + }, + { + SetMasterContractApproval: [ + { name: "warning", type: "string" }, + { name: "user", type: "address" }, + { name: "masterContract", type: "address" }, + { name: "approved", type: "bool" }, + { name: "nonce", type: "uint256" }, + ], + }, + { + warning: "Give FULL access to funds in (and approved to) BentoBox?", + user: user.address, + masterContract: contractToApprove, + approved, + nonce: nonces, + } + ); + + return splitSignature(signature); +} diff --git a/test/utils/impersonate.ts b/test/utils/impersonate.ts new file mode 100644 index 00000000..bd1ccb28 --- /dev/null +++ b/test/utils/impersonate.ts @@ -0,0 +1,42 @@ +import { JsonRpcProvider } from "@ethersproject/providers"; +import { parseEther } from "@ethersproject/units"; +import { ethers } from "hardhat"; +import { randomHex } from "./encoding"; + +const TEN_THOUSAND_ETH = parseEther("10000").toHexString().replace("0x0", "0x"); + +export const impersonate = async ( + address: string, + provider: JsonRpcProvider +) => { + await provider.send("hardhat_impersonateAccount", [address]); + await faucet(address, provider); +}; + +export const faucet = async (address: string, provider: JsonRpcProvider) => { + await provider.send("hardhat_setBalance", [address, TEN_THOUSAND_ETH]); +}; + +export const getWalletWithEther = async () => { + const wallet = new ethers.Wallet(randomHex(32), ethers.provider); + await faucet(wallet.address, ethers.provider); + return wallet; +}; + +export const stopImpersonation = async ( + address: string, + provider: JsonRpcProvider +) => { + await provider.send("hardhat_stopImpersonatingAccount", [address]); +}; + +export const whileImpersonating = async ( + address: string, + provider: JsonRpcProvider, + fn: () => T +) => { + await impersonate(address, provider); + const result = await fn(); + await stopImpersonation(address, provider); + return result; +}; diff --git a/test/utils/seeded-rng.js b/test/utils/seeded-rng.js new file mode 100644 index 00000000..927790cf --- /dev/null +++ b/test/utils/seeded-rng.js @@ -0,0 +1,279 @@ +/* eslint-disable new-cap */ +/* eslint-disable no-control-regex */ +/* + * random-seed + * https://github.com/skratchdot/random-seed + * + * This code was originally written by Steve Gibson and can be found here: + * + * https://www.grc.com/otg/uheprng.htm + * + * It was slightly modified for use in node, to pass jshint, and a few additional + * helper functions were added. + * + * Copyright (c) 2013 skratchdot + * Dual Licensed under the MIT license and the original GRC copyright/license + * included below. + */ +/* ============================================================================ + Gibson Research Corporation + UHEPRNG - Ultra High Entropy Pseudo-Random Number Generator + ============================================================================ + LICENSE AND COPYRIGHT: THIS CODE IS HEREBY RELEASED INTO THE PUBLIC DOMAIN + Gibson Research Corporation releases and disclaims ALL RIGHTS AND TITLE IN + THIS CODE OR ANY DERIVATIVES. Anyone may be freely use it for any purpose. + ============================================================================ + This is GRC's cryptographically strong PRNG (pseudo-random number generator) + for JavaScript. It is driven by 1536 bits of entropy, stored in an array of + 48, 32-bit JavaScript variables. Since many applications of this generator, + including ours with the "Off The Grid" Latin Square generator, may require + the deterministic re-generation of a sequence of PRNs, this PRNG's initial + entropic state can be read and written as a static whole, and incrementally + evolved by pouring new source entropy into the generator's internal state. + ---------------------------------------------------------------------------- + ENDLESS THANKS are due Johannes Baagoe for his careful development of highly + robust JavaScript implementations of JS PRNGs. This work was based upon his + JavaScript "Alea" PRNG which is based upon the extremely robust Multiply- + With-Carry (MWC) PRNG invented by George Marsaglia. MWC Algorithm References: + http://www.GRC.com/otg/Marsaglia_PRNGs.pdf + http://www.GRC.com/otg/Marsaglia_MWC_Generators.pdf + ---------------------------------------------------------------------------- + The quality of this algorithm's pseudo-random numbers have been verified by + multiple independent researchers. It handily passes the fermilab.ch tests as + well as the "diehard" and "dieharder" test suites. For individuals wishing + to further verify the quality of this algorithm's pseudo-random numbers, a + 256-megabyte file of this algorithm's output may be downloaded from GRC.com, + and a Microsoft Windows scripting host (WSH) version of this algorithm may be + downloaded and run from the Windows command prompt to generate unique files + of any size: + The Fermilab "ENT" tests: http://fourmilab.ch/random/ + The 256-megabyte sample PRN file at GRC: https://www.GRC.com/otg/uheprng.bin + The Windows scripting host version: https://www.GRC.com/otg/wsh-uheprng.js + ---------------------------------------------------------------------------- + Qualifying MWC multipliers are: 187884, 686118, 898134, 1104375, 1250205, + 1460910 and 1768863. (We use the largest one that's < 2^21) + ============================================================================ */ +"use strict"; +const stringify = JSON.stringify; + +/* ============================================================================ + This is based upon Johannes Baagoe's carefully designed and efficient hash + function for use with JavaScript. It has a proven "avalanche" effect such + that every bit of the input affects every bit of the output 50% of the time, + which is good. See: http://baagoe.com/en/RandomMusings/hash/avalanche.xhtml + ============================================================================ + */ +const Mash = function () { + let n = 0xefc8249d; + const mash = function (data) { + if (data) { + data = data.toString(); + for (let i = 0; i < data.length; i++) { + n += data.charCodeAt(i); + let h = 0.02519603282416938 * n; + n = h >>> 0; + h -= n; + h *= n; + n = h >>> 0; + h -= n; + n += h * 0x100000000; // 2^32 + } + return (n >>> 0) * 2.3283064365386963e-10; // 2^-32 + } else { + n = 0xefc8249d; + } + }; + return mash; +}; + +const uheprng = function (seed) { + return (function () { + const o = 48; // set the 'order' number of ENTROPY-holding 32-bit values + let c = 1; // init the 'carry' used by the multiply-with-carry (MWC) algorithm + let p = o; // init the 'phase' (max-1) of the intermediate variable pointer + const s = new Array(o); // declare our intermediate variables array + let i; // general purpose local + let j; // general purpose local + let k = 0; // general purpose local + + // when our "uheprng" is initially invoked our PRNG state is initialized from the + // browser's own local PRNG. This is okay since although its generator might not + // be wonderful, it's useful for establishing large startup entropy for our usage. + let mash = new Mash(); // get a pointer to our high-performance "Mash" hash + + // fill the array with initial mash hash values + for (i = 0; i < o; i++) { + s[i] = mash(Math.random()); + } + + // this PRIVATE (internal access only) function is the heart of the multiply-with-carry + // (MWC) PRNG algorithm. When called it returns a pseudo-random number in the form of a + // 32-bit JavaScript fraction (0.0 to <1.0) it is a PRIVATE function used by the default + // [0-1] return function, and by the random 'string(n)' function which returns 'n' + // characters from 33 to 126. + const rawprng = function () { + if (++p >= o) { + p = 0; + } + const t = 1768863 * s[p] + c * 2.3283064365386963e-10; // 2^-32 + return (s[p] = t - (c = t | 0)); + }; + + // this EXPORTED function is the default function returned by this library. + // The values returned are integers in the range from 0 to range-1. We first + // obtain two 32-bit fractions (from rawprng) to synthesize a single high + // resolution 53-bit prng (0 to <1), then we multiply this by the caller's + // "range" param and take the "floor" to return a equally probable integer. + const random = function (range) { + return Math.floor( + range * + (rawprng() + ((rawprng() * 0x200000) | 0) * 1.1102230246251565e-16) + ); // 2^-53 + }; + + // this EXPORTED function 'string(n)' returns a pseudo-random string of + // 'n' printable characters ranging from chr(33) to chr(126) inclusive. + random.string = function (count) { + let i; + let s = ""; + for (i = 0; i < count; i++) { + s += String.fromCharCode(33 + random(94)); + } + return s; + }; + + // this PRIVATE "hash" function is used to evolve the generator's internal + // entropy state. It is also called by the EXPORTED addEntropy() function + // which is used to pour entropy into the PRNG. + const hash = function () { + const args = Array.prototype.slice.call(arguments); + for (i = 0; i < args.length; i++) { + for (j = 0; j < o; j++) { + s[j] -= mash(args[i]); + if (s[j] < 0) { + s[j] += 1; + } + } + } + }; + + // this EXPORTED "clean string" function removes leading and trailing spaces and non-printing + // control characters, including any embedded carriage-return (CR) and line-feed (LF) characters, + // from any string it is handed. this is also used by the 'hashstring' function (below) to help + // users always obtain the same EFFECTIVE uheprng seeding key. + random.cleanString = function (inStr) { + inStr = inStr.replace(/(^\s*)|(\s*$)/gi, ""); // remove any/all leading spaces + inStr = inStr.replace(/[\x00-\x1F]/gi, ""); // remove any/all control characters + inStr = inStr.replace(/\n /, "\n"); // remove any/all trailing spaces + return inStr; // return the cleaned up result + }; + + // this EXPORTED "hash string" function hashes the provided character string after first removing + // any leading or trailing spaces and ignoring any embedded carriage returns (CR) or Line Feeds (LF) + random.hashString = function (inStr) { + inStr = random.cleanString(inStr); + mash(inStr); // use the string to evolve the 'mash' state + for (i = 0; i < inStr.length; i++) { + // scan through the characters in our string + k = inStr.charCodeAt(i); // get the character code at the location + for (j = 0; j < o; j++) { + // "mash" it into the UHEPRNG state + s[j] -= mash(k); + if (s[j] < 0) { + s[j] += 1; + } + } + } + }; + + // this EXPORTED function allows you to seed the random generator. + random.seed = function (seed) { + if (typeof seed === "undefined" || seed === null) { + seed = Math.random(); + } + if (typeof seed !== "string") { + seed = stringify(seed, function (key, value) { + if (typeof value === "function") { + return value.toString(); + } + return value; + }); + } + random.initState(); + random.hashString(seed); + }; + + // this handy exported function is used to add entropy to our uheprng at any time + random.addEntropy = function (/* accept zero or more arguments */) { + const args = []; + for (i = 0; i < arguments.length; i++) { + args.push(arguments[i]); + } + hash(k++ + new Date().getTime() + args.join("") + Math.random()); + }; + + // if we want to provide a deterministic startup context for our PRNG, + // but without directly setting the internal state variables, this allows + // us to initialize the mash hash and PRNG's internal state before providing + // some hashing input + random.initState = function () { + mash(); // pass a null arg to force mash hash to init + for (i = 0; i < o; i++) { + s[i] = mash(" "); // fill the array with initial mash hash values + } + c = 1; // init our multiply-with-carry carry + p = o; // init our phase + }; + + // we use this (optional) exported function to signal the JavaScript interpreter + // that we're finished using the "Mash" hash function so that it can free up the + // local "instance variables" is will have been maintaining. It's not strictly + // necessary, of course, but it's good JavaScript citizenship. + random.done = function () { + mash = null; + }; + + // if we called "uheprng" with a seed value, then execute random.seed() before returning + if (typeof seed !== "undefined") { + random.seed(seed); + } + + // Returns a random integer between 0 (inclusive) and range (exclusive) + random.range = function (range) { + return random(range); + }; + + // Returns a random float between 0 (inclusive) and 1 (exclusive) + random.random = function () { + return random(Number.MAX_VALUE - 1) / Number.MAX_VALUE; + }; + + random.randomBytes = function (bytes = 1) { + return [...Array(bytes * 2)].map(() => random(16).toString(16)).join(""); + }; + + // Returns a random float between min (inclusive) and max (exclusive) + random.floatBetween = function (min, max) { + return random.random() * (max - min) + min; + }; + + // Returns a random integer between min (inclusive) and max (inclusive) + random.intBetween = function (min, max) { + return Math.floor(random.random() * (max - min + 1)) + min; + }; + + // when our main outer "uheprng" function is called, after setting up our + // initial variables and entropic state, we return an "instance pointer" + // to the internal anonymous function which can then be used to access + // the uheprng's various exported functions. As with the ".done" function + // above, we should set the returned value to 'null' once we're finished + // using any of these functions. + return random; + })(); +}; + +// Modification for use in node: +uheprng.create = function (seed) { + return new uheprng(seed); +}; +module.exports = uheprng; diff --git a/test/utils/sign.ts b/test/utils/sign.ts new file mode 100644 index 00000000..e69de29b diff --git a/test/utils/types.ts b/test/utils/types.ts new file mode 100644 index 00000000..898286ae --- /dev/null +++ b/test/utils/types.ts @@ -0,0 +1,92 @@ +import { BigNumber } from "ethers"; + +export type BigNumberish = string | BigNumber | number | boolean; + +export type AdditionalRecipient = { + amount: BigNumber; + recipient: string; +}; + +export type FulfillmentComponent = { + orderIndex: number; + itemIndex: number; +}; + +export type CriteriaResolver = { + orderIndex: number; + side: 0 | 1; + index: number; + identifier: BigNumber; + criteriaProof: string[]; +}; + +export type BasicOrderParameters = { + considerationToken: string; + considerationIdentifier: BigNumber; + considerationAmount: BigNumber; + offerer: string; + zone: string; + offerToken: string; + offerIdentifier: BigNumber; + offerAmount: BigNumber; + basicOrderType: number; + startTime: string | BigNumber | number; + endTime: string | BigNumber | number; + zoneHash: string; + salt: string; + offererConduitKey: string; + fulfillerConduitKey: string; + totalOriginalAdditionalRecipients: BigNumber; + additionalRecipients: AdditionalRecipient[]; + signature: string; +}; + +export type OfferItem = { + itemType: number; + token: string; + identifierOrCriteria: BigNumber; + startAmount: BigNumber; + endAmount: BigNumber; +}; +export type ConsiderationItem = { + itemType: number; + token: string; + identifierOrCriteria: BigNumber; + startAmount: BigNumber; + endAmount: BigNumber; + recipient: string; +}; + +export type OrderParameters = { + offerer: string; + zone: string; + offer: OfferItem[]; + consideration: ConsiderationItem[]; + orderType: number; + startTime: string | BigNumber | number; + endTime: string | BigNumber | number; + zoneHash: string; + salt: string; + conduitKey: string; + totalOriginalConsiderationItems: string | BigNumber | number; +}; + +export type OrderComponents = Omit< + OrderParameters, + "totalOriginalConsiderationItems" +> & { + counter: BigNumber; +}; + +export type Order = { + parameters: OrderParameters; + signature: string; +}; + +export type AdvancedOrder = { + parameters: OrderParameters; + numerator: string | BigNumber | number; + denominator: string | BigNumber | number; + signature: string; + extraData: string; +}; diff --git a/tsconfig.json b/tsconfig.json new file mode 100644 index 00000000..2f0ba906 --- /dev/null +++ b/tsconfig.json @@ -0,0 +1,13 @@ +{ + "compilerOptions": { + "target": "es2018", + "module": "commonjs", + "strict": true, + "esModuleInterop": true, + "outDir": "dist", + "declaration": true, + "resolveJsonModule": true + }, + "include": ["./scripts", "./test", "./typechain-types"], + "files": ["./hardhat.config.ts"] +} diff --git a/yarn.lock b/yarn.lock new file mode 100644 index 00000000..ed3fbf30 --- /dev/null +++ b/yarn.lock @@ -0,0 +1,11346 @@ +# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. +# yarn lockfile v1 + + +"@babel/code-frame@^7.0.0": + version "7.16.7" + resolved "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.16.7.tgz" + integrity sha512-iAXqUn8IIeBTNd72xsFlgaXHkMBMt6y4HJp1tIaK465CWLT/fG1aqB7ykr95gHHmlBdGbFeWWfyB4NJJ0nmeIg== + dependencies: + "@babel/highlight" "^7.16.7" + +"@babel/helper-validator-identifier@^7.16.7": + version "7.16.7" + resolved "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.16.7.tgz" + integrity sha512-hsEnFemeiW4D08A5gUAZxLBTXpZ39P+a+DGDsHw1yxqyQ/jzFEnxf5uTEGp+3bzAbNOxU1paTgYS4ECU/IgfDw== + +"@babel/highlight@^7.16.7": + version "7.17.9" + resolved "https://registry.npmjs.org/@babel/highlight/-/highlight-7.17.9.tgz" + integrity sha512-J9PfEKCbFIv2X5bjTMiZu6Vf341N05QIY+d6FvVKynkG1S7G0j3I0QoRtWIrXhZ+/Nlb5Q0MzqL7TokEJ5BNHg== + dependencies: + "@babel/helper-validator-identifier" "^7.16.7" + chalk "^2.0.0" + js-tokens "^4.0.0" + +"@cspotcode/source-map-consumer@0.8.0": + version "0.8.0" + resolved "https://registry.npmjs.org/@cspotcode/source-map-consumer/-/source-map-consumer-0.8.0.tgz" + integrity sha512-41qniHzTU8yAGbCp04ohlmSrZf8bkf/iJsl3V0dRGsQN/5GFfx+LbCSsCpp2gqrqjTVg/K6O8ycoV35JIwAzAg== + +"@cspotcode/source-map-support@0.7.0": + version "0.7.0" + resolved "https://registry.npmjs.org/@cspotcode/source-map-support/-/source-map-support-0.7.0.tgz" + integrity sha512-X4xqRHqN8ACt2aHVe51OxeA2HjbcL4MqFqXkrmQszJ1NOUuUu5u6Vqx/0lZSVNku7velL5FC/s5uEAj1lsBMhA== + dependencies: + "@cspotcode/source-map-consumer" "0.8.0" + +"@ensdomains/ens@^0.4.4": + version "0.4.5" + resolved "https://registry.npmjs.org/@ensdomains/ens/-/ens-0.4.5.tgz" + integrity sha512-JSvpj1iNMFjK6K+uVl4unqMoa9rf5jopb8cya5UGBWz23Nw8hSNT7efgUx4BTlAPAgpNlEioUfeTyQ6J9ZvTVw== + dependencies: + bluebird "^3.5.2" + eth-ens-namehash "^2.0.8" + solc "^0.4.20" + testrpc "0.0.1" + web3-utils "^1.0.0-beta.31" + +"@ensdomains/resolver@^0.2.4": + version "0.2.4" + resolved "https://registry.npmjs.org/@ensdomains/resolver/-/resolver-0.2.4.tgz" + integrity sha512-bvaTH34PMCbv6anRa9I/0zjLJgY4EuznbEMgbV77JBCQ9KNC46rzi0avuxpOfu+xDjPEtSFGqVEOr5GlUSGudA== + +"@eslint/eslintrc@^1.2.2": + version "1.2.2" + resolved "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-1.2.2.tgz" + integrity sha512-lTVWHs7O2hjBFZunXTZYnYqtB9GakA1lnxIf+gKq2nY5gxkkNi/lQvveW6t8gFdOHTg6nG50Xs95PrLqVpcaLg== + dependencies: + ajv "^6.12.4" + debug "^4.3.2" + espree "^9.3.1" + globals "^13.9.0" + ignore "^5.2.0" + import-fresh "^3.2.1" + js-yaml "^4.1.0" + minimatch "^3.0.4" + strip-json-comments "^3.1.1" + +"@ethereum-waffle/chai@^3.4.4": + version "3.4.4" + resolved "https://registry.npmjs.org/@ethereum-waffle/chai/-/chai-3.4.4.tgz" + integrity sha512-/K8czydBtXXkcM9X6q29EqEkc5dN3oYenyH2a9hF7rGAApAJUpH8QBtojxOY/xQ2up5W332jqgxwp0yPiYug1g== + dependencies: + "@ethereum-waffle/provider" "^3.4.4" + ethers "^5.5.2" + +"@ethereum-waffle/compiler@^3.4.4": + version "3.4.4" + resolved "https://registry.yarnpkg.com/@ethereum-waffle/compiler/-/compiler-3.4.4.tgz#d568ee0f6029e68b5c645506079fbf67d0dfcf19" + integrity sha512-RUK3axJ8IkD5xpWjWoJgyHclOeEzDLQFga6gKpeGxiS/zBu+HB0W2FvsrrLalTFIaPw/CGYACRBSIxqiCqwqTQ== + dependencies: + "@resolver-engine/imports" "^0.3.3" + "@resolver-engine/imports-fs" "^0.3.3" + "@typechain/ethers-v5" "^2.0.0" + "@types/mkdirp" "^0.5.2" + "@types/node-fetch" "^2.5.5" + ethers "^5.0.1" + mkdirp "^0.5.1" + node-fetch "^2.6.1" + solc "^0.6.3" + ts-generator "^0.1.1" + typechain "^3.0.0" + +"@ethereum-waffle/ens@^3.4.4": + version "3.4.4" + resolved "https://registry.npmjs.org/@ethereum-waffle/ens/-/ens-3.4.4.tgz" + integrity sha512-0m4NdwWxliy3heBYva1Wr4WbJKLnwXizmy5FfSSr5PMbjI7SIGCdCB59U7/ZzY773/hY3bLnzLwvG5mggVjJWg== + dependencies: + "@ensdomains/ens" "^0.4.4" + "@ensdomains/resolver" "^0.2.4" + ethers "^5.5.2" + +"@ethereum-waffle/mock-contract@^3.4.4": + version "3.4.4" + resolved "https://registry.npmjs.org/@ethereum-waffle/mock-contract/-/mock-contract-3.4.4.tgz" + integrity sha512-Mp0iB2YNWYGUV+VMl5tjPsaXKbKo8MDH9wSJ702l9EBjdxFf/vBvnMBAC1Fub1lLtmD0JHtp1pq+mWzg/xlLnA== + dependencies: + "@ethersproject/abi" "^5.5.0" + ethers "^5.5.2" + +"@ethereum-waffle/provider@^3.4.4": + version "3.4.4" + resolved "https://registry.npmjs.org/@ethereum-waffle/provider/-/provider-3.4.4.tgz" + integrity sha512-GK8oKJAM8+PKy2nK08yDgl4A80mFuI8zBkE0C9GqTRYQqvuxIyXoLmJ5NZU9lIwyWVv5/KsoA11BgAv2jXE82g== + dependencies: + "@ethereum-waffle/ens" "^3.4.4" + ethers "^5.5.2" + ganache-core "^2.13.2" + patch-package "^6.2.2" + postinstall-postinstall "^2.1.0" + +"@ethereumjs/block@^3.5.0", "@ethereumjs/block@^3.6.0", "@ethereumjs/block@^3.6.2": + version "3.6.2" + resolved "https://registry.npmjs.org/@ethereumjs/block/-/block-3.6.2.tgz" + integrity sha512-mOqYWwMlAZpYUEOEqt7EfMFuVL2eyLqWWIzcf4odn6QgXY8jBI2NhVuJncrMCKeMZrsJAe7/auaRRB6YcdH+Qw== + dependencies: + "@ethereumjs/common" "^2.6.3" + "@ethereumjs/tx" "^3.5.1" + ethereumjs-util "^7.1.4" + merkle-patricia-tree "^4.2.4" + +"@ethereumjs/blockchain@^5.5.0", "@ethereumjs/blockchain@^5.5.2": + version "5.5.2" + resolved "https://registry.npmjs.org/@ethereumjs/blockchain/-/blockchain-5.5.2.tgz" + integrity sha512-Jz26iJmmsQtngerW6r5BDFaew/f2mObLrRZo3rskLOx1lmtMZ8+TX/vJexmivrnWgmAsTdNWhlKUYY4thPhPig== + dependencies: + "@ethereumjs/block" "^3.6.2" + "@ethereumjs/common" "^2.6.3" + "@ethereumjs/ethash" "^1.1.0" + debug "^4.3.3" + ethereumjs-util "^7.1.4" + level-mem "^5.0.1" + lru-cache "^5.1.1" + semaphore-async-await "^1.5.1" + +"@ethereumjs/common@^2.3.0", "@ethereumjs/common@^2.4.0", "@ethereumjs/common@^2.6.0", "@ethereumjs/common@^2.6.3", "@ethereumjs/common@^2.6.4": + version "2.6.4" + resolved "https://registry.npmjs.org/@ethereumjs/common/-/common-2.6.4.tgz" + integrity sha512-RDJh/R/EAr+B7ZRg5LfJ0BIpf/1LydFgYdvZEuTraojCbVypO2sQ+QnpP5u2wJf9DASyooKqu8O4FJEWUV6NXw== + dependencies: + crc-32 "^1.2.0" + ethereumjs-util "^7.1.4" + +"@ethereumjs/ethash@^1.1.0": + version "1.1.0" + resolved "https://registry.npmjs.org/@ethereumjs/ethash/-/ethash-1.1.0.tgz" + integrity sha512-/U7UOKW6BzpA+Vt+kISAoeDie1vAvY4Zy2KF5JJb+So7+1yKmJeJEHOGSnQIj330e9Zyl3L5Nae6VZyh2TJnAA== + dependencies: + "@ethereumjs/block" "^3.5.0" + "@types/levelup" "^4.3.0" + buffer-xor "^2.0.1" + ethereumjs-util "^7.1.1" + miller-rabin "^4.0.0" + +"@ethereumjs/tx@^3.2.1", "@ethereumjs/tx@^3.4.0", "@ethereumjs/tx@^3.5.1": + version "3.5.1" + resolved "https://registry.npmjs.org/@ethereumjs/tx/-/tx-3.5.1.tgz" + integrity sha512-xzDrTiu4sqZXUcaBxJ4n4W5FrppwxLxZB4ZDGVLtxSQR4lVuOnFR6RcUHdg1mpUhAPVrmnzLJpxaeXnPxIyhWA== + dependencies: + "@ethereumjs/common" "^2.6.3" + ethereumjs-util "^7.1.4" + +"@ethereumjs/vm@^5.6.0": + version "5.9.0" + resolved "https://registry.npmjs.org/@ethereumjs/vm/-/vm-5.9.0.tgz" + integrity sha512-0IRsj4IuF8lFDWVVLc4mFOImaSX8VWF8CGm3mXHG/LLlQ/Tryy/kKXMw/bU9D+Zw03CdteW+wCGqNFS6+mPjpg== + dependencies: + "@ethereumjs/block" "^3.6.2" + "@ethereumjs/blockchain" "^5.5.2" + "@ethereumjs/common" "^2.6.4" + "@ethereumjs/tx" "^3.5.1" + async-eventemitter "^0.2.4" + core-js-pure "^3.0.1" + debug "^4.3.3" + ethereumjs-util "^7.1.4" + functional-red-black-tree "^1.0.1" + mcl-wasm "^0.7.1" + merkle-patricia-tree "^4.2.4" + rustbn.js "~0.2.0" + +"@ethersproject/abi@5.0.0-beta.153": + version "5.0.0-beta.153" + resolved "https://registry.npmjs.org/@ethersproject/abi/-/abi-5.0.0-beta.153.tgz" + integrity sha512-aXweZ1Z7vMNzJdLpR1CZUAIgnwjrZeUSvN9syCwlBaEBUFJmFY+HHnfuTI5vIhVs/mRkfJVrbEyl51JZQqyjAg== + dependencies: + "@ethersproject/address" ">=5.0.0-beta.128" + "@ethersproject/bignumber" ">=5.0.0-beta.130" + "@ethersproject/bytes" ">=5.0.0-beta.129" + "@ethersproject/constants" ">=5.0.0-beta.128" + "@ethersproject/hash" ">=5.0.0-beta.128" + "@ethersproject/keccak256" ">=5.0.0-beta.127" + "@ethersproject/logger" ">=5.0.0-beta.129" + "@ethersproject/properties" ">=5.0.0-beta.131" + "@ethersproject/strings" ">=5.0.0-beta.130" + +"@ethersproject/abi@5.0.7": + version "5.0.7" + resolved "https://registry.npmjs.org/@ethersproject/abi/-/abi-5.0.7.tgz" + integrity sha512-Cqktk+hSIckwP/W8O47Eef60VwmoSC/L3lY0+dIBhQPCNn9E4V7rwmm2aFrNRRDJfFlGuZ1khkQUOc3oBX+niw== + dependencies: + "@ethersproject/address" "^5.0.4" + "@ethersproject/bignumber" "^5.0.7" + "@ethersproject/bytes" "^5.0.4" + "@ethersproject/constants" "^5.0.4" + "@ethersproject/hash" "^5.0.4" + "@ethersproject/keccak256" "^5.0.3" + "@ethersproject/logger" "^5.0.5" + "@ethersproject/properties" "^5.0.3" + "@ethersproject/strings" "^5.0.4" + +"@ethersproject/abi@5.6.1", "@ethersproject/abi@^5.0.0-beta.146", "@ethersproject/abi@^5.1.2", "@ethersproject/abi@^5.5.0", "@ethersproject/abi@^5.6.0": + version "5.6.1" + resolved "https://registry.npmjs.org/@ethersproject/abi/-/abi-5.6.1.tgz" + integrity sha512-0cqssYh6FXjlwKWBmLm3+zH2BNARoS5u/hxbz+LpQmcDB3w0W553h2btWui1/uZp2GBM/SI3KniTuMcYyHpA5w== + dependencies: + "@ethersproject/address" "^5.6.0" + "@ethersproject/bignumber" "^5.6.0" + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/constants" "^5.6.0" + "@ethersproject/hash" "^5.6.0" + "@ethersproject/keccak256" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/strings" "^5.6.0" + +"@ethersproject/abi@5.6.3", "@ethersproject/abi@^5.6.3": + version "5.6.3" + resolved "https://registry.yarnpkg.com/@ethersproject/abi/-/abi-5.6.3.tgz#2d643544abadf6e6b63150508af43475985c23db" + integrity sha512-CxKTdoZY4zDJLWXG6HzNH6znWK0M79WzzxHegDoecE3+K32pzfHOzuXg2/oGSTecZynFgpkjYXNPOqXVJlqClw== + dependencies: + "@ethersproject/address" "^5.6.1" + "@ethersproject/bignumber" "^5.6.2" + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/constants" "^5.6.1" + "@ethersproject/hash" "^5.6.1" + "@ethersproject/keccak256" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/strings" "^5.6.1" + +"@ethersproject/abstract-provider@5.6.0", "@ethersproject/abstract-provider@^5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/abstract-provider/-/abstract-provider-5.6.0.tgz" + integrity sha512-oPMFlKLN+g+y7a79cLK3WiLcjWFnZQtXWgnLAbHZcN3s7L4v90UHpTOrLk+m3yr0gt+/h9STTM6zrr7PM8uoRw== + dependencies: + "@ethersproject/bignumber" "^5.6.0" + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/networks" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/transactions" "^5.6.0" + "@ethersproject/web" "^5.6.0" + +"@ethersproject/abstract-provider@5.6.1", "@ethersproject/abstract-provider@^5.6.1": + version "5.6.1" + resolved "https://registry.yarnpkg.com/@ethersproject/abstract-provider/-/abstract-provider-5.6.1.tgz#02ddce150785caf0c77fe036a0ebfcee61878c59" + integrity sha512-BxlIgogYJtp1FS8Muvj8YfdClk3unZH0vRMVX791Z9INBNT/kuACZ9GzaY1Y4yFq+YSy6/w4gzj3HCRKrK9hsQ== + dependencies: + "@ethersproject/bignumber" "^5.6.2" + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/networks" "^5.6.3" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/transactions" "^5.6.2" + "@ethersproject/web" "^5.6.1" + +"@ethersproject/abstract-signer@5.6.0", "@ethersproject/abstract-signer@^5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/abstract-signer/-/abstract-signer-5.6.0.tgz" + integrity sha512-WOqnG0NJKtI8n0wWZPReHtaLkDByPL67tn4nBaDAhmVq8sjHTPbCdz4DRhVu/cfTOvfy9w3iq5QZ7BX7zw56BQ== + dependencies: + "@ethersproject/abstract-provider" "^5.6.0" + "@ethersproject/bignumber" "^5.6.0" + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + +"@ethersproject/abstract-signer@5.6.2", "@ethersproject/abstract-signer@^5.6.2": + version "5.6.2" + resolved "https://registry.yarnpkg.com/@ethersproject/abstract-signer/-/abstract-signer-5.6.2.tgz#491f07fc2cbd5da258f46ec539664713950b0b33" + integrity sha512-n1r6lttFBG0t2vNiI3HoWaS/KdOt8xyDjzlP2cuevlWLG6EX0OwcKLyG/Kp/cuwNxdy/ous+R/DEMdTUwWQIjQ== + dependencies: + "@ethersproject/abstract-provider" "^5.6.1" + "@ethersproject/bignumber" "^5.6.2" + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + +"@ethersproject/address@5.6.0", "@ethersproject/address@>=5.0.0-beta.128", "@ethersproject/address@^5.0.4", "@ethersproject/address@^5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/address/-/address-5.6.0.tgz" + integrity sha512-6nvhYXjbXsHPS+30sHZ+U4VMagFC/9zAk6Gd/h3S21YW4+yfb0WfRtaAIZ4kfM4rrVwqiy284LP0GtL5HXGLxQ== + dependencies: + "@ethersproject/bignumber" "^5.6.0" + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/keccak256" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/rlp" "^5.6.0" + +"@ethersproject/address@5.6.1", "@ethersproject/address@^5.0.2", "@ethersproject/address@^5.4.0", "@ethersproject/address@^5.6.1": + version "5.6.1" + resolved "https://registry.yarnpkg.com/@ethersproject/address/-/address-5.6.1.tgz#ab57818d9aefee919c5721d28cd31fd95eff413d" + integrity sha512-uOgF0kS5MJv9ZvCz7x6T2EXJSzotiybApn4XlOgoTX0xdtyVIJ7pF+6cGPxiEq/dpBiTfMiw7Yc81JcwhSYA0Q== + dependencies: + "@ethersproject/bignumber" "^5.6.2" + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/keccak256" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/rlp" "^5.6.1" + +"@ethersproject/base64@5.6.0", "@ethersproject/base64@^5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/base64/-/base64-5.6.0.tgz" + integrity sha512-2Neq8wxJ9xHxCF9TUgmKeSh9BXJ6OAxWfeGWvbauPh8FuHEjamgHilllx8KkSd5ErxyHIX7Xv3Fkcud2kY9ezw== + dependencies: + "@ethersproject/bytes" "^5.6.0" + +"@ethersproject/base64@5.6.1", "@ethersproject/base64@^5.6.1": + version "5.6.1" + resolved "https://registry.yarnpkg.com/@ethersproject/base64/-/base64-5.6.1.tgz#2c40d8a0310c9d1606c2c37ae3092634b41d87cb" + integrity sha512-qB76rjop6a0RIYYMiB4Eh/8n+Hxu2NIZm8S/Q7kNo5pmZfXhHGHmS4MinUainiBC54SCyRnwzL+KZjj8zbsSsw== + dependencies: + "@ethersproject/bytes" "^5.6.1" + +"@ethersproject/basex@5.6.0", "@ethersproject/basex@^5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/basex/-/basex-5.6.0.tgz" + integrity sha512-qN4T+hQd/Md32MoJpc69rOwLYRUXwjTlhHDIeUkUmiN/JyWkkLLMoG0TqvSQKNqZOMgN5stbUYN6ILC+eD7MEQ== + dependencies: + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + +"@ethersproject/basex@5.6.1", "@ethersproject/basex@^5.6.1": + version "5.6.1" + resolved "https://registry.yarnpkg.com/@ethersproject/basex/-/basex-5.6.1.tgz#badbb2f1d4a6f52ce41c9064f01eab19cc4c5305" + integrity sha512-a52MkVz4vuBXR06nvflPMotld1FJWSj2QT0985v7P/emPZO00PucFAkbcmq2vpVU7Ts7umKiSI6SppiLykVWsA== + dependencies: + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/properties" "^5.6.0" + +"@ethersproject/bignumber@5.6.0", "@ethersproject/bignumber@>=5.0.0-beta.130", "@ethersproject/bignumber@^5.0.7", "@ethersproject/bignumber@^5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/bignumber/-/bignumber-5.6.0.tgz" + integrity sha512-VziMaXIUHQlHJmkv1dlcd6GY2PmT0khtAqaMctCIDogxkrarMzA9L94KN1NeXqqOfFD6r0sJT3vCTOFSmZ07DA== + dependencies: + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + bn.js "^4.11.9" + +"@ethersproject/bignumber@5.6.2", "@ethersproject/bignumber@^5.4.0", "@ethersproject/bignumber@^5.6.2": + version "5.6.2" + resolved "https://registry.yarnpkg.com/@ethersproject/bignumber/-/bignumber-5.6.2.tgz#72a0717d6163fab44c47bcc82e0c550ac0315d66" + integrity sha512-v7+EEUbhGqT3XJ9LMPsKvXYHFc8eHxTowFCG/HgJErmq4XHJ2WR7aeyICg3uTOAQ7Icn0GFHAohXEhxQHq4Ubw== + dependencies: + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + bn.js "^5.2.1" + +"@ethersproject/bytes@5.6.1", "@ethersproject/bytes@>=5.0.0-beta.129", "@ethersproject/bytes@^5.0.4", "@ethersproject/bytes@^5.6.0", "@ethersproject/bytes@^5.6.1": + version "5.6.1" + resolved "https://registry.npmjs.org/@ethersproject/bytes/-/bytes-5.6.1.tgz" + integrity sha512-NwQt7cKn5+ZE4uDn+X5RAXLp46E1chXoaMmrxAyA0rblpxz8t58lVkrHXoRIn0lz1joQElQ8410GqhTqMOwc6g== + dependencies: + "@ethersproject/logger" "^5.6.0" + +"@ethersproject/constants@5.6.0", "@ethersproject/constants@>=5.0.0-beta.128", "@ethersproject/constants@^5.0.4", "@ethersproject/constants@^5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/constants/-/constants-5.6.0.tgz" + integrity sha512-SrdaJx2bK0WQl23nSpV/b1aq293Lh0sUaZT/yYKPDKn4tlAbkH96SPJwIhwSwTsoQQZxuh1jnqsKwyymoiBdWA== + dependencies: + "@ethersproject/bignumber" "^5.6.0" + +"@ethersproject/constants@5.6.1", "@ethersproject/constants@^5.6.1": + version "5.6.1" + resolved "https://registry.yarnpkg.com/@ethersproject/constants/-/constants-5.6.1.tgz#e2e974cac160dd101cf79fdf879d7d18e8cb1370" + integrity sha512-QSq9WVnZbxXYFftrjSjZDUshp6/eKp6qrtdBtUCm0QxCV5z1fG/w3kdlcsjMCQuQHUnAclKoK7XpXMezhRDOLg== + dependencies: + "@ethersproject/bignumber" "^5.6.2" + +"@ethersproject/contracts@5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/contracts/-/contracts-5.6.0.tgz" + integrity sha512-74Ge7iqTDom0NX+mux8KbRUeJgu1eHZ3iv6utv++sLJG80FVuU9HnHeKVPfjd9s3woFhaFoQGf3B3iH/FrQmgw== + dependencies: + "@ethersproject/abi" "^5.6.0" + "@ethersproject/abstract-provider" "^5.6.0" + "@ethersproject/abstract-signer" "^5.6.0" + "@ethersproject/address" "^5.6.0" + "@ethersproject/bignumber" "^5.6.0" + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/constants" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/transactions" "^5.6.0" + +"@ethersproject/contracts@5.6.2": + version "5.6.2" + resolved "https://registry.yarnpkg.com/@ethersproject/contracts/-/contracts-5.6.2.tgz#20b52e69ebc1b74274ff8e3d4e508de971c287bc" + integrity sha512-hguUA57BIKi6WY0kHvZp6PwPlWF87MCeB4B7Z7AbUpTxfFXFdn/3b0GmjZPagIHS+3yhcBJDnuEfU4Xz+Ks/8g== + dependencies: + "@ethersproject/abi" "^5.6.3" + "@ethersproject/abstract-provider" "^5.6.1" + "@ethersproject/abstract-signer" "^5.6.2" + "@ethersproject/address" "^5.6.1" + "@ethersproject/bignumber" "^5.6.2" + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/constants" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/transactions" "^5.6.2" + +"@ethersproject/hash@5.6.0", "@ethersproject/hash@>=5.0.0-beta.128", "@ethersproject/hash@^5.0.4", "@ethersproject/hash@^5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/hash/-/hash-5.6.0.tgz" + integrity sha512-fFd+k9gtczqlr0/BruWLAu7UAOas1uRRJvOR84uDf4lNZ+bTkGl366qvniUZHKtlqxBRU65MkOobkmvmpHU+jA== + dependencies: + "@ethersproject/abstract-signer" "^5.6.0" + "@ethersproject/address" "^5.6.0" + "@ethersproject/bignumber" "^5.6.0" + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/keccak256" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/strings" "^5.6.0" + +"@ethersproject/hash@5.6.1", "@ethersproject/hash@^5.6.1": + version "5.6.1" + resolved "https://registry.yarnpkg.com/@ethersproject/hash/-/hash-5.6.1.tgz#224572ea4de257f05b4abf8ae58b03a67e99b0f4" + integrity sha512-L1xAHurbaxG8VVul4ankNX5HgQ8PNCTrnVXEiFnE9xoRnaUcgfD12tZINtDinSllxPLCtGwguQxJ5E6keE84pA== + dependencies: + "@ethersproject/abstract-signer" "^5.6.2" + "@ethersproject/address" "^5.6.1" + "@ethersproject/bignumber" "^5.6.2" + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/keccak256" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/strings" "^5.6.1" + +"@ethersproject/hdnode@5.6.0", "@ethersproject/hdnode@^5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/hdnode/-/hdnode-5.6.0.tgz" + integrity sha512-61g3Jp3nwDqJcL/p4nugSyLrpl/+ChXIOtCEM8UDmWeB3JCAt5FoLdOMXQc3WWkc0oM2C0aAn6GFqqMcS/mHTw== + dependencies: + "@ethersproject/abstract-signer" "^5.6.0" + "@ethersproject/basex" "^5.6.0" + "@ethersproject/bignumber" "^5.6.0" + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/pbkdf2" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/sha2" "^5.6.0" + "@ethersproject/signing-key" "^5.6.0" + "@ethersproject/strings" "^5.6.0" + "@ethersproject/transactions" "^5.6.0" + "@ethersproject/wordlists" "^5.6.0" + +"@ethersproject/hdnode@5.6.2", "@ethersproject/hdnode@^5.6.2": + version "5.6.2" + resolved "https://registry.yarnpkg.com/@ethersproject/hdnode/-/hdnode-5.6.2.tgz#26f3c83a3e8f1b7985c15d1db50dc2903418b2d2" + integrity sha512-tERxW8Ccf9CxW2db3WsN01Qao3wFeRsfYY9TCuhmG0xNpl2IO8wgXU3HtWIZ49gUWPggRy4Yg5axU0ACaEKf1Q== + dependencies: + "@ethersproject/abstract-signer" "^5.6.2" + "@ethersproject/basex" "^5.6.1" + "@ethersproject/bignumber" "^5.6.2" + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/pbkdf2" "^5.6.1" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/sha2" "^5.6.1" + "@ethersproject/signing-key" "^5.6.2" + "@ethersproject/strings" "^5.6.1" + "@ethersproject/transactions" "^5.6.2" + "@ethersproject/wordlists" "^5.6.1" + +"@ethersproject/json-wallets@5.6.0", "@ethersproject/json-wallets@^5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/json-wallets/-/json-wallets-5.6.0.tgz" + integrity sha512-fmh86jViB9r0ibWXTQipxpAGMiuxoqUf78oqJDlCAJXgnJF024hOOX7qVgqsjtbeoxmcLwpPsXNU0WEe/16qPQ== + dependencies: + "@ethersproject/abstract-signer" "^5.6.0" + "@ethersproject/address" "^5.6.0" + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/hdnode" "^5.6.0" + "@ethersproject/keccak256" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/pbkdf2" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/random" "^5.6.0" + "@ethersproject/strings" "^5.6.0" + "@ethersproject/transactions" "^5.6.0" + aes-js "3.0.0" + scrypt-js "3.0.1" + +"@ethersproject/json-wallets@5.6.1", "@ethersproject/json-wallets@^5.6.1": + version "5.6.1" + resolved "https://registry.yarnpkg.com/@ethersproject/json-wallets/-/json-wallets-5.6.1.tgz#3f06ba555c9c0d7da46756a12ac53483fe18dd91" + integrity sha512-KfyJ6Zwz3kGeX25nLihPwZYlDqamO6pfGKNnVMWWfEVVp42lTfCZVXXy5Ie8IZTN0HKwAngpIPi7gk4IJzgmqQ== + dependencies: + "@ethersproject/abstract-signer" "^5.6.2" + "@ethersproject/address" "^5.6.1" + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/hdnode" "^5.6.2" + "@ethersproject/keccak256" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/pbkdf2" "^5.6.1" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/random" "^5.6.1" + "@ethersproject/strings" "^5.6.1" + "@ethersproject/transactions" "^5.6.2" + aes-js "3.0.0" + scrypt-js "3.0.1" + +"@ethersproject/keccak256@5.6.0", "@ethersproject/keccak256@>=5.0.0-beta.127", "@ethersproject/keccak256@^5.0.3", "@ethersproject/keccak256@^5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/keccak256/-/keccak256-5.6.0.tgz" + integrity sha512-tk56BJ96mdj/ksi7HWZVWGjCq0WVl/QvfhFQNeL8fxhBlGoP+L80uDCiQcpJPd+2XxkivS3lwRm3E0CXTfol0w== + dependencies: + "@ethersproject/bytes" "^5.6.0" + js-sha3 "0.8.0" + +"@ethersproject/keccak256@5.6.1", "@ethersproject/keccak256@^5.6.1": + version "5.6.1" + resolved "https://registry.yarnpkg.com/@ethersproject/keccak256/-/keccak256-5.6.1.tgz#b867167c9b50ba1b1a92bccdd4f2d6bd168a91cc" + integrity sha512-bB7DQHCTRDooZZdL3lk9wpL0+XuG3XLGHLh3cePnybsO3V0rdCAOQGpn/0R3aODmnTOOkCATJiD2hnL+5bwthA== + dependencies: + "@ethersproject/bytes" "^5.6.1" + js-sha3 "0.8.0" + +"@ethersproject/logger@5.6.0", "@ethersproject/logger@>=5.0.0-beta.129", "@ethersproject/logger@^5.0.5", "@ethersproject/logger@^5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/logger/-/logger-5.6.0.tgz" + integrity sha512-BiBWllUROH9w+P21RzoxJKzqoqpkyM1pRnEKG69bulE9TSQD8SAIvTQqIMZmmCO8pUNkgLP1wndX1gKghSpBmg== + +"@ethersproject/networks@5.6.2", "@ethersproject/networks@^5.6.0": + version "5.6.2" + resolved "https://registry.npmjs.org/@ethersproject/networks/-/networks-5.6.2.tgz" + integrity sha512-9uEzaJY7j5wpYGTojGp8U89mSsgQLc40PCMJLMCnFXTs7nhBveZ0t7dbqWUNrepWTszDbFkYD6WlL8DKx5huHA== + dependencies: + "@ethersproject/logger" "^5.6.0" + +"@ethersproject/networks@5.6.3", "@ethersproject/networks@^5.6.3": + version "5.6.3" + resolved "https://registry.yarnpkg.com/@ethersproject/networks/-/networks-5.6.3.tgz#3ee3ab08f315b433b50c99702eb32e0cf31f899f" + integrity sha512-QZxRH7cA5Ut9TbXwZFiCyuPchdWi87ZtVNHWZd0R6YFgYtes2jQ3+bsslJ0WdyDe0i6QumqtoYqvY3rrQFRZOQ== + dependencies: + "@ethersproject/logger" "^5.6.0" + +"@ethersproject/pbkdf2@5.6.0", "@ethersproject/pbkdf2@^5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/pbkdf2/-/pbkdf2-5.6.0.tgz" + integrity sha512-Wu1AxTgJo3T3H6MIu/eejLFok9TYoSdgwRr5oGY1LTLfmGesDoSx05pemsbrPT2gG4cQME+baTSCp5sEo2erZQ== + dependencies: + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/sha2" "^5.6.0" + +"@ethersproject/pbkdf2@5.6.1", "@ethersproject/pbkdf2@^5.6.1": + version "5.6.1" + resolved "https://registry.yarnpkg.com/@ethersproject/pbkdf2/-/pbkdf2-5.6.1.tgz#f462fe320b22c0d6b1d72a9920a3963b09eb82d1" + integrity sha512-k4gRQ+D93zDRPNUfmduNKq065uadC2YjMP/CqwwX5qG6R05f47boq6pLZtV/RnC4NZAYOPH1Cyo54q0c9sshRQ== + dependencies: + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/sha2" "^5.6.1" + +"@ethersproject/properties@5.6.0", "@ethersproject/properties@>=5.0.0-beta.131", "@ethersproject/properties@^5.0.3", "@ethersproject/properties@^5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/properties/-/properties-5.6.0.tgz" + integrity sha512-szoOkHskajKePTJSZ46uHUWWkbv7TzP2ypdEK6jGMqJaEt2sb0jCgfBo0gH0m2HBpRixMuJ6TBRaQCF7a9DoCg== + dependencies: + "@ethersproject/logger" "^5.6.0" + +"@ethersproject/providers@5.6.4": + version "5.6.4" + resolved "https://registry.npmjs.org/@ethersproject/providers/-/providers-5.6.4.tgz" + integrity sha512-WAdknnaZ52hpHV3qPiJmKx401BLpup47h36Axxgre9zT+doa/4GC/Ne48ICPxTm0BqndpToHjpLP1ZnaxyE+vw== + dependencies: + "@ethersproject/abstract-provider" "^5.6.0" + "@ethersproject/abstract-signer" "^5.6.0" + "@ethersproject/address" "^5.6.0" + "@ethersproject/basex" "^5.6.0" + "@ethersproject/bignumber" "^5.6.0" + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/constants" "^5.6.0" + "@ethersproject/hash" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/networks" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/random" "^5.6.0" + "@ethersproject/rlp" "^5.6.0" + "@ethersproject/sha2" "^5.6.0" + "@ethersproject/strings" "^5.6.0" + "@ethersproject/transactions" "^5.6.0" + "@ethersproject/web" "^5.6.0" + bech32 "1.1.4" + ws "7.4.6" + +"@ethersproject/providers@5.6.8", "@ethersproject/providers@^5.4.0": + version "5.6.8" + resolved "https://registry.yarnpkg.com/@ethersproject/providers/-/providers-5.6.8.tgz#22e6c57be215ba5545d3a46cf759d265bb4e879d" + integrity sha512-Wf+CseT/iOJjrGtAOf3ck9zS7AgPmr2fZ3N97r4+YXN3mBePTG2/bJ8DApl9mVwYL+RpYbNxMEkEp4mPGdwG/w== + dependencies: + "@ethersproject/abstract-provider" "^5.6.1" + "@ethersproject/abstract-signer" "^5.6.2" + "@ethersproject/address" "^5.6.1" + "@ethersproject/base64" "^5.6.1" + "@ethersproject/basex" "^5.6.1" + "@ethersproject/bignumber" "^5.6.2" + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/constants" "^5.6.1" + "@ethersproject/hash" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/networks" "^5.6.3" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/random" "^5.6.1" + "@ethersproject/rlp" "^5.6.1" + "@ethersproject/sha2" "^5.6.1" + "@ethersproject/strings" "^5.6.1" + "@ethersproject/transactions" "^5.6.2" + "@ethersproject/web" "^5.6.1" + bech32 "1.1.4" + ws "7.4.6" + +"@ethersproject/random@5.6.0", "@ethersproject/random@^5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/random/-/random-5.6.0.tgz" + integrity sha512-si0PLcLjq+NG/XHSZz90asNf+YfKEqJGVdxoEkSukzbnBgC8rydbgbUgBbBGLeHN4kAJwUFEKsu3sCXT93YMsw== + dependencies: + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + +"@ethersproject/random@5.6.1", "@ethersproject/random@^5.6.1": + version "5.6.1" + resolved "https://registry.yarnpkg.com/@ethersproject/random/-/random-5.6.1.tgz#66915943981bcd3e11bbd43733f5c3ba5a790255" + integrity sha512-/wtPNHwbmng+5yi3fkipA8YBT59DdkGRoC2vWk09Dci/q5DlgnMkhIycjHlavrvrjJBkFjO/ueLyT+aUDfc4lA== + dependencies: + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + +"@ethersproject/rlp@5.6.0", "@ethersproject/rlp@^5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/rlp/-/rlp-5.6.0.tgz" + integrity sha512-dz9WR1xpcTL+9DtOT/aDO+YyxSSdO8YIS0jyZwHHSlAmnxA6cKU3TrTd4Xc/bHayctxTgGLYNuVVoiXE4tTq1g== + dependencies: + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + +"@ethersproject/rlp@5.6.1", "@ethersproject/rlp@^5.6.1": + version "5.6.1" + resolved "https://registry.yarnpkg.com/@ethersproject/rlp/-/rlp-5.6.1.tgz#df8311e6f9f24dcb03d59a2bac457a28a4fe2bd8" + integrity sha512-uYjmcZx+DKlFUk7a5/W9aQVaoEC7+1MOBgNtvNg13+RnuUwT4F0zTovC0tmay5SmRslb29V1B7Y5KCri46WhuQ== + dependencies: + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + +"@ethersproject/sha2@5.6.0", "@ethersproject/sha2@^5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/sha2/-/sha2-5.6.0.tgz" + integrity sha512-1tNWCPFLu1n3JM9t4/kytz35DkuF9MxqkGGEHNauEbaARdm2fafnOyw1s0tIQDPKF/7bkP1u3dbrmjpn5CelyA== + dependencies: + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + hash.js "1.1.7" + +"@ethersproject/sha2@5.6.1", "@ethersproject/sha2@^5.6.1": + version "5.6.1" + resolved "https://registry.yarnpkg.com/@ethersproject/sha2/-/sha2-5.6.1.tgz#211f14d3f5da5301c8972a8827770b6fd3e51656" + integrity sha512-5K2GyqcW7G4Yo3uenHegbXRPDgARpWUiXc6RiF7b6i/HXUoWlb7uCARh7BAHg7/qT/Q5ydofNwiZcim9qpjB6g== + dependencies: + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + hash.js "1.1.7" + +"@ethersproject/signing-key@5.6.0", "@ethersproject/signing-key@^5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/signing-key/-/signing-key-5.6.0.tgz" + integrity sha512-S+njkhowmLeUu/r7ir8n78OUKx63kBdMCPssePS89So1TH4hZqnWFsThEd/GiXYp9qMxVrydf7KdM9MTGPFukA== + dependencies: + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + bn.js "^4.11.9" + elliptic "6.5.4" + hash.js "1.1.7" + +"@ethersproject/signing-key@5.6.2", "@ethersproject/signing-key@^5.6.2": + version "5.6.2" + resolved "https://registry.yarnpkg.com/@ethersproject/signing-key/-/signing-key-5.6.2.tgz#8a51b111e4d62e5a62aee1da1e088d12de0614a3" + integrity sha512-jVbu0RuP7EFpw82vHcL+GP35+KaNruVAZM90GxgQnGqB6crhBqW/ozBfFvdeImtmb4qPko0uxXjn8l9jpn0cwQ== + dependencies: + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + bn.js "^5.2.1" + elliptic "6.5.4" + hash.js "1.1.7" + +"@ethersproject/solidity@5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/solidity/-/solidity-5.6.0.tgz" + integrity sha512-YwF52vTNd50kjDzqKaoNNbC/r9kMDPq3YzDWmsjFTRBcIF1y4JCQJ8gB30wsTfHbaxgxelI5BfxQSxD/PbJOww== + dependencies: + "@ethersproject/bignumber" "^5.6.0" + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/keccak256" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/sha2" "^5.6.0" + "@ethersproject/strings" "^5.6.0" + +"@ethersproject/solidity@5.6.1", "@ethersproject/solidity@^5.4.0": + version "5.6.1" + resolved "https://registry.yarnpkg.com/@ethersproject/solidity/-/solidity-5.6.1.tgz#5845e71182c66d32e6ec5eefd041fca091a473e2" + integrity sha512-KWqVLkUUoLBfL1iwdzUVlkNqAUIFMpbbeH0rgCfKmJp0vFtY4AsaN91gHKo9ZZLkC4UOm3cI3BmMV4N53BOq4g== + dependencies: + "@ethersproject/bignumber" "^5.6.2" + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/keccak256" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/sha2" "^5.6.1" + "@ethersproject/strings" "^5.6.1" + +"@ethersproject/strings@5.6.0", "@ethersproject/strings@>=5.0.0-beta.130", "@ethersproject/strings@^5.0.4", "@ethersproject/strings@^5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/strings/-/strings-5.6.0.tgz" + integrity sha512-uv10vTtLTZqrJuqBZR862ZQjTIa724wGPWQqZrofaPI/kUsf53TBG0I0D+hQ1qyNtllbNzaW+PDPHHUI6/65Mg== + dependencies: + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/constants" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + +"@ethersproject/strings@5.6.1", "@ethersproject/strings@^5.6.1": + version "5.6.1" + resolved "https://registry.yarnpkg.com/@ethersproject/strings/-/strings-5.6.1.tgz#dbc1b7f901db822b5cafd4ebf01ca93c373f8952" + integrity sha512-2X1Lgk6Jyfg26MUnsHiT456U9ijxKUybz8IM1Vih+NJxYtXhmvKBcHOmvGqpFSVJ0nQ4ZCoIViR8XlRw1v/+Cw== + dependencies: + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/constants" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + +"@ethersproject/transactions@5.6.0", "@ethersproject/transactions@^5.0.0-beta.135", "@ethersproject/transactions@^5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/transactions/-/transactions-5.6.0.tgz" + integrity sha512-4HX+VOhNjXHZyGzER6E/LVI2i6lf9ejYeWD6l4g50AdmimyuStKc39kvKf1bXWQMg7QNVh+uC7dYwtaZ02IXeg== + dependencies: + "@ethersproject/address" "^5.6.0" + "@ethersproject/bignumber" "^5.6.0" + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/constants" "^5.6.0" + "@ethersproject/keccak256" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/rlp" "^5.6.0" + "@ethersproject/signing-key" "^5.6.0" + +"@ethersproject/transactions@5.6.2", "@ethersproject/transactions@^5.6.2": + version "5.6.2" + resolved "https://registry.yarnpkg.com/@ethersproject/transactions/-/transactions-5.6.2.tgz#793a774c01ced9fe7073985bb95a4b4e57a6370b" + integrity sha512-BuV63IRPHmJvthNkkt9G70Ullx6AcM+SDc+a8Aw/8Yew6YwT51TcBKEp1P4oOQ/bP25I18JJr7rcFRgFtU9B2Q== + dependencies: + "@ethersproject/address" "^5.6.1" + "@ethersproject/bignumber" "^5.6.2" + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/constants" "^5.6.1" + "@ethersproject/keccak256" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/rlp" "^5.6.1" + "@ethersproject/signing-key" "^5.6.2" + +"@ethersproject/units@5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/units/-/units-5.6.0.tgz" + integrity sha512-tig9x0Qmh8qbo1w8/6tmtyrm/QQRviBh389EQ+d8fP4wDsBrJBf08oZfoiz1/uenKK9M78yAP4PoR7SsVoTjsw== + dependencies: + "@ethersproject/bignumber" "^5.6.0" + "@ethersproject/constants" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + +"@ethersproject/units@5.6.1": + version "5.6.1" + resolved "https://registry.yarnpkg.com/@ethersproject/units/-/units-5.6.1.tgz#ecc590d16d37c8f9ef4e89e2005bda7ddc6a4e6f" + integrity sha512-rEfSEvMQ7obcx3KWD5EWWx77gqv54K6BKiZzKxkQJqtpriVsICrktIQmKl8ReNToPeIYPnFHpXvKpi068YFZXw== + dependencies: + "@ethersproject/bignumber" "^5.6.2" + "@ethersproject/constants" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + +"@ethersproject/wallet@5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/wallet/-/wallet-5.6.0.tgz" + integrity sha512-qMlSdOSTyp0MBeE+r7SUhr1jjDlC1zAXB8VD84hCnpijPQiSNbxr6GdiLXxpUs8UKzkDiNYYC5DRI3MZr+n+tg== + dependencies: + "@ethersproject/abstract-provider" "^5.6.0" + "@ethersproject/abstract-signer" "^5.6.0" + "@ethersproject/address" "^5.6.0" + "@ethersproject/bignumber" "^5.6.0" + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/hash" "^5.6.0" + "@ethersproject/hdnode" "^5.6.0" + "@ethersproject/json-wallets" "^5.6.0" + "@ethersproject/keccak256" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/random" "^5.6.0" + "@ethersproject/signing-key" "^5.6.0" + "@ethersproject/transactions" "^5.6.0" + "@ethersproject/wordlists" "^5.6.0" + +"@ethersproject/wallet@5.6.2": + version "5.6.2" + resolved "https://registry.yarnpkg.com/@ethersproject/wallet/-/wallet-5.6.2.tgz#cd61429d1e934681e413f4bc847a5f2f87e3a03c" + integrity sha512-lrgh0FDQPuOnHcF80Q3gHYsSUODp6aJLAdDmDV0xKCN/T7D99ta1jGVhulg3PY8wiXEngD0DfM0I2XKXlrqJfg== + dependencies: + "@ethersproject/abstract-provider" "^5.6.1" + "@ethersproject/abstract-signer" "^5.6.2" + "@ethersproject/address" "^5.6.1" + "@ethersproject/bignumber" "^5.6.2" + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/hash" "^5.6.1" + "@ethersproject/hdnode" "^5.6.2" + "@ethersproject/json-wallets" "^5.6.1" + "@ethersproject/keccak256" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/random" "^5.6.1" + "@ethersproject/signing-key" "^5.6.2" + "@ethersproject/transactions" "^5.6.2" + "@ethersproject/wordlists" "^5.6.1" + +"@ethersproject/web@5.6.0", "@ethersproject/web@^5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/web/-/web-5.6.0.tgz" + integrity sha512-G/XHj0hV1FxI2teHRfCGvfBUHFmU+YOSbCxlAMqJklxSa7QMiHFQfAxvwY2PFqgvdkxEKwRNr/eCjfAPEm2Ctg== + dependencies: + "@ethersproject/base64" "^5.6.0" + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/strings" "^5.6.0" + +"@ethersproject/web@5.6.1", "@ethersproject/web@^5.6.1": + version "5.6.1" + resolved "https://registry.yarnpkg.com/@ethersproject/web/-/web-5.6.1.tgz#6e2bd3ebadd033e6fe57d072db2b69ad2c9bdf5d" + integrity sha512-/vSyzaQlNXkO1WV+RneYKqCJwualcUdx/Z3gseVovZP0wIlOFcCE1hkRhKBH8ImKbGQbMl9EAAyJFrJu7V0aqA== + dependencies: + "@ethersproject/base64" "^5.6.1" + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/strings" "^5.6.1" + +"@ethersproject/wordlists@5.6.0", "@ethersproject/wordlists@^5.6.0": + version "5.6.0" + resolved "https://registry.npmjs.org/@ethersproject/wordlists/-/wordlists-5.6.0.tgz" + integrity sha512-q0bxNBfIX3fUuAo9OmjlEYxP40IB8ABgb7HjEZCL5IKubzV3j30CWi2rqQbjTS2HfoyQbfINoKcTVWP4ejwR7Q== + dependencies: + "@ethersproject/bytes" "^5.6.0" + "@ethersproject/hash" "^5.6.0" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/strings" "^5.6.0" + +"@ethersproject/wordlists@5.6.1", "@ethersproject/wordlists@^5.6.1": + version "5.6.1" + resolved "https://registry.yarnpkg.com/@ethersproject/wordlists/-/wordlists-5.6.1.tgz#1e78e2740a8a21e9e99947e47979d72e130aeda1" + integrity sha512-wiPRgBpNbNwCQFoCr8bcWO8o5I810cqO6mkdtKfLKFlLxeCWcnzDi4Alu8iyNzlhYuS9npCwivMbRWF19dyblw== + dependencies: + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/hash" "^5.6.1" + "@ethersproject/logger" "^5.6.0" + "@ethersproject/properties" "^5.6.0" + "@ethersproject/strings" "^5.6.1" + +"@humanwhocodes/config-array@^0.9.2": + version "0.9.5" + resolved "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.9.5.tgz" + integrity sha512-ObyMyWxZiCu/yTisA7uzx81s40xR2fD5Cg/2Kq7G02ajkNubJf6BopgDTmDyc3U7sXpNKM8cYOw7s7Tyr+DnCw== + dependencies: + "@humanwhocodes/object-schema" "^1.2.1" + debug "^4.1.1" + minimatch "^3.0.4" + +"@humanwhocodes/object-schema@^1.2.1": + version "1.2.1" + resolved "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz" + integrity sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA== + +"@metamask/eth-sig-util@^4.0.0": + version "4.0.1" + resolved "https://registry.npmjs.org/@metamask/eth-sig-util/-/eth-sig-util-4.0.1.tgz" + integrity sha512-tghyZKLHZjcdlDqCA3gNZmLeR0XvOE9U1qoQO9ohyAZT6Pya+H9vkBPcsyXytmYLNgVoin7CKCmweo/R43V+tQ== + dependencies: + ethereumjs-abi "^0.6.8" + ethereumjs-util "^6.2.1" + ethjs-util "^0.1.6" + tweetnacl "^1.0.3" + tweetnacl-util "^0.15.1" + +"@noble/hashes@1.0.0", "@noble/hashes@~1.0.0": + version "1.0.0" + resolved "https://registry.npmjs.org/@noble/hashes/-/hashes-1.0.0.tgz" + integrity sha512-DZVbtY62kc3kkBtMHqwCOfXrT/hnoORy5BJ4+HU1IR59X0KWAOqsfzQPcUl/lQLlG7qXbe/fZ3r/emxtAl+sqg== + +"@noble/secp256k1@1.5.5", "@noble/secp256k1@~1.5.2": + version "1.5.5" + resolved "https://registry.npmjs.org/@noble/secp256k1/-/secp256k1-1.5.5.tgz" + integrity sha512-sZ1W6gQzYnu45wPrWx8D3kwI2/U29VYTx9OjbDAd7jwRItJ0cSTMPRL/C8AWZFn9kWFLQGqEXVEE86w4Z8LpIQ== + +"@nodelib/fs.scandir@2.1.5": + version "2.1.5" + resolved "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz" + integrity sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g== + dependencies: + "@nodelib/fs.stat" "2.0.5" + run-parallel "^1.1.9" + +"@nodelib/fs.stat@2.0.5", "@nodelib/fs.stat@^2.0.2": + version "2.0.5" + resolved "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz" + integrity sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A== + +"@nodelib/fs.walk@^1.2.3": + version "1.2.8" + resolved "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz" + integrity sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg== + dependencies: + "@nodelib/fs.scandir" "2.1.5" + fastq "^1.6.0" + +"@nomiclabs/hardhat-ethers@npm:hardhat-deploy-ethers", hardhat-deploy-ethers@^0.3.0-beta.13: + version "0.3.0-beta.13" + resolved "https://registry.yarnpkg.com/hardhat-deploy-ethers/-/hardhat-deploy-ethers-0.3.0-beta.13.tgz#b96086ff768ddf69928984d5eb0a8d78cfca9366" + integrity sha512-PdWVcKB9coqWV1L7JTpfXRCI91Cgwsm7KLmBcwZ8f0COSm1xtABHZTyz3fvF6p42cTnz1VM0QnfDvMFlIRkSNw== + +"@nomiclabs/hardhat-etherscan@^3.1.0": + version "3.1.0" + resolved "https://registry.yarnpkg.com/@nomiclabs/hardhat-etherscan/-/hardhat-etherscan-3.1.0.tgz#7137554862b3b1c914f1b1bf110f0529fd2dec53" + integrity sha512-JroYgfN1AlYFkQTQ3nRwFi4o8NtZF7K/qFR2dxDUgHbCtIagkUseca9L4E/D2ScUm4XT40+8PbCdqZi+XmHyQA== + dependencies: + "@ethersproject/abi" "^5.1.2" + "@ethersproject/address" "^5.0.2" + cbor "^5.0.2" + chalk "^2.4.2" + debug "^4.1.1" + fs-extra "^7.0.1" + lodash "^4.17.11" + semver "^6.3.0" + table "^6.8.0" + undici "^5.4.0" + +"@nomiclabs/hardhat-waffle@^2.0.1": + version "2.0.3" + resolved "https://registry.npmjs.org/@nomiclabs/hardhat-waffle/-/hardhat-waffle-2.0.3.tgz" + integrity sha512-049PHSnI1CZq6+XTbrMbMv5NaL7cednTfPenx02k3cEh8wBMLa6ys++dBETJa6JjfwgA9nBhhHQ173LJv6k2Pg== + dependencies: + "@types/sinon-chai" "^3.2.3" + "@types/web3" "1.0.19" + +"@openzeppelin/contracts-upgradeable@^4.7.0": + version "4.7.0" + resolved "https://registry.yarnpkg.com/@openzeppelin/contracts-upgradeable/-/contracts-upgradeable-4.7.0.tgz#6437261286879d353f6de7bf3ac8216bef8a486d" + integrity sha512-wO3PyoAaAV/rA77cK8H4c3SbO98QylTjfiFxyvURUZKTFLV180rnAvna1x7/Nxvt0Gqv+jt1sXKC7ygxsq8iCw== + +"@openzeppelin/contracts@^4.7.0": + version "4.7.0" + resolved "https://registry.yarnpkg.com/@openzeppelin/contracts/-/contracts-4.7.0.tgz#3092d70ea60e3d1835466266b1d68ad47035a2d5" + integrity sha512-52Qb+A1DdOss8QvJrijYYPSf32GUg2pGaG/yCxtaA3cu4jduouTdg4XZSMLW9op54m1jH7J8hoajhHKOPsoJFw== + +"@openzeppelin/hardhat-upgrades@^1.19.0": + version "1.19.0" + resolved "https://registry.yarnpkg.com/@openzeppelin/hardhat-upgrades/-/hardhat-upgrades-1.19.0.tgz#8f17210b924eb04c3ea4aa9795c1bb01d8a7dc3f" + integrity sha512-351QqDO3nZ96g0BO/bQnaTflix4Nw4ELWC/hZ8PwicsuVxRmxN/GZhxPrs62AOdiQdZ+xweawrVXa5knliRd4A== + dependencies: + "@openzeppelin/upgrades-core" "^1.16.0" + chalk "^4.1.0" + proper-lockfile "^4.1.1" + +"@openzeppelin/upgrades-core@^1.16.0": + version "1.16.1" + resolved "https://registry.yarnpkg.com/@openzeppelin/upgrades-core/-/upgrades-core-1.16.1.tgz#a4c383fc628cc9d37d5a276def99a093c951644b" + integrity sha512-+hejbeAfsZWIQL5Ih13gkdm2KO6kbERc1ektzcyb25/OtUwaRjIIHxW++LdC/3Hg5uzThVOzJBfiLdAbgwD+OA== + dependencies: + bn.js "^5.1.2" + cbor "^8.0.0" + chalk "^4.1.0" + compare-versions "^4.0.0" + debug "^4.1.1" + ethereumjs-util "^7.0.3" + proper-lockfile "^4.1.1" + solidity-ast "^0.4.15" + +"@rari-capital/solmate@^6.2.0": + version "6.2.0" + resolved "https://registry.npmjs.org/@rari-capital/solmate/-/solmate-6.2.0.tgz" + integrity sha512-g94F+Ra9ixyJyNgvnOIufNjUz488uEG0nxIEEtJ7+g+tA1XGUupRB2kB5b+VO7WYO26RNOVD2fW6xE4e14iWpg== + +"@resolver-engine/core@^0.3.3": + version "0.3.3" + resolved "https://registry.npmjs.org/@resolver-engine/core/-/core-0.3.3.tgz" + integrity sha512-eB8nEbKDJJBi5p5SrvrvILn4a0h42bKtbCTri3ZxCGt6UvoQyp7HnGOfki944bUjBSHKK3RvgfViHn+kqdXtnQ== + dependencies: + debug "^3.1.0" + is-url "^1.2.4" + request "^2.85.0" + +"@resolver-engine/fs@^0.3.3": + version "0.3.3" + resolved "https://registry.npmjs.org/@resolver-engine/fs/-/fs-0.3.3.tgz" + integrity sha512-wQ9RhPUcny02Wm0IuJwYMyAG8fXVeKdmhm8xizNByD4ryZlx6PP6kRen+t/haF43cMfmaV7T3Cx6ChOdHEhFUQ== + dependencies: + "@resolver-engine/core" "^0.3.3" + debug "^3.1.0" + +"@resolver-engine/imports-fs@^0.3.3": + version "0.3.3" + resolved "https://registry.npmjs.org/@resolver-engine/imports-fs/-/imports-fs-0.3.3.tgz" + integrity sha512-7Pjg/ZAZtxpeyCFlZR5zqYkz+Wdo84ugB5LApwriT8XFeQoLwGUj4tZFFvvCuxaNCcqZzCYbonJgmGObYBzyCA== + dependencies: + "@resolver-engine/fs" "^0.3.3" + "@resolver-engine/imports" "^0.3.3" + debug "^3.1.0" + +"@resolver-engine/imports@^0.3.3": + version "0.3.3" + resolved "https://registry.npmjs.org/@resolver-engine/imports/-/imports-0.3.3.tgz" + integrity sha512-anHpS4wN4sRMwsAbMXhMfOD/y4a4Oo0Cw/5+rue7hSwGWsDOQaAU1ClK1OxjUC35/peazxEl8JaSRRS+Xb8t3Q== + dependencies: + "@resolver-engine/core" "^0.3.3" + debug "^3.1.0" + hosted-git-info "^2.6.0" + path-browserify "^1.0.0" + url "^0.11.0" + +"@scure/base@~1.0.0": + version "1.0.0" + resolved "https://registry.npmjs.org/@scure/base/-/base-1.0.0.tgz" + integrity sha512-gIVaYhUsy+9s58m/ETjSJVKHhKTBMmcRb9cEV5/5dwvfDlfORjKrFsDeDHWRrm6RjcPvCLZFwGJjAjLj1gg4HA== + +"@scure/bip32@1.0.1": + version "1.0.1" + resolved "https://registry.npmjs.org/@scure/bip32/-/bip32-1.0.1.tgz" + integrity sha512-AU88KKTpQ+YpTLoicZ/qhFhRRIo96/tlb+8YmDDHR9yiKVjSsFZiefJO4wjS2PMTkz5/oIcw84uAq/8pleQURA== + dependencies: + "@noble/hashes" "~1.0.0" + "@noble/secp256k1" "~1.5.2" + "@scure/base" "~1.0.0" + +"@scure/bip39@1.0.0": + version "1.0.0" + resolved "https://registry.npmjs.org/@scure/bip39/-/bip39-1.0.0.tgz" + integrity sha512-HrtcikLbd58PWOkl02k9V6nXWQyoa7A0+Ek9VF7z17DDk9XZAFUcIdqfh0jJXLypmizc5/8P6OxoUeKliiWv4w== + dependencies: + "@noble/hashes" "~1.0.0" + "@scure/base" "~1.0.0" + +"@sentry/core@5.30.0": + version "5.30.0" + resolved "https://registry.npmjs.org/@sentry/core/-/core-5.30.0.tgz" + integrity sha512-TmfrII8w1PQZSZgPpUESqjB+jC6MvZJZdLtE/0hZ+SrnKhW3x5WlYLvTXZpcWePYBku7rl2wn1RZu6uT0qCTeg== + dependencies: + "@sentry/hub" "5.30.0" + "@sentry/minimal" "5.30.0" + "@sentry/types" "5.30.0" + "@sentry/utils" "5.30.0" + tslib "^1.9.3" + +"@sentry/hub@5.30.0": + version "5.30.0" + resolved "https://registry.npmjs.org/@sentry/hub/-/hub-5.30.0.tgz" + integrity sha512-2tYrGnzb1gKz2EkMDQcfLrDTvmGcQPuWxLnJKXJvYTQDGLlEvi2tWz1VIHjunmOvJrB5aIQLhm+dcMRwFZDCqQ== + dependencies: + "@sentry/types" "5.30.0" + "@sentry/utils" "5.30.0" + tslib "^1.9.3" + +"@sentry/minimal@5.30.0": + version "5.30.0" + resolved "https://registry.npmjs.org/@sentry/minimal/-/minimal-5.30.0.tgz" + integrity sha512-BwWb/owZKtkDX+Sc4zCSTNcvZUq7YcH3uAVlmh/gtR9rmUvbzAA3ewLuB3myi4wWRAMEtny6+J/FN/x+2wn9Xw== + dependencies: + "@sentry/hub" "5.30.0" + "@sentry/types" "5.30.0" + tslib "^1.9.3" + +"@sentry/node@^5.18.1": + version "5.30.0" + resolved "https://registry.npmjs.org/@sentry/node/-/node-5.30.0.tgz" + integrity sha512-Br5oyVBF0fZo6ZS9bxbJZG4ApAjRqAnqFFurMVJJdunNb80brh7a5Qva2kjhm+U6r9NJAB5OmDyPkA1Qnt+QVg== + dependencies: + "@sentry/core" "5.30.0" + "@sentry/hub" "5.30.0" + "@sentry/tracing" "5.30.0" + "@sentry/types" "5.30.0" + "@sentry/utils" "5.30.0" + cookie "^0.4.1" + https-proxy-agent "^5.0.0" + lru_map "^0.3.3" + tslib "^1.9.3" + +"@sentry/tracing@5.30.0": + version "5.30.0" + resolved "https://registry.npmjs.org/@sentry/tracing/-/tracing-5.30.0.tgz" + integrity sha512-dUFowCr0AIMwiLD7Fs314Mdzcug+gBVo/+NCMyDw8tFxJkwWAKl7Qa2OZxLQ0ZHjakcj1hNKfCQJ9rhyfOl4Aw== + dependencies: + "@sentry/hub" "5.30.0" + "@sentry/minimal" "5.30.0" + "@sentry/types" "5.30.0" + "@sentry/utils" "5.30.0" + tslib "^1.9.3" + +"@sentry/types@5.30.0": + version "5.30.0" + resolved "https://registry.npmjs.org/@sentry/types/-/types-5.30.0.tgz" + integrity sha512-R8xOqlSTZ+htqrfteCWU5Nk0CDN5ApUTvrlvBuiH1DyP6czDZ4ktbZB0hAgBlVcK0U+qpD3ag3Tqqpa5Q67rPw== + +"@sentry/utils@5.30.0": + version "5.30.0" + resolved "https://registry.npmjs.org/@sentry/utils/-/utils-5.30.0.tgz" + integrity sha512-zaYmoH0NWWtvnJjC9/CBseXMtKHm/tm40sz3YfJRxeQjyzRqNQPgivpd9R/oDJCYj999mzdW382p/qi2ypjLww== + dependencies: + "@sentry/types" "5.30.0" + tslib "^1.9.3" + +"@sindresorhus/is@^0.14.0": + version "0.14.0" + resolved "https://registry.npmjs.org/@sindresorhus/is/-/is-0.14.0.tgz" + integrity sha512-9NET910DNaIPngYnLLPeg+Ogzqsi9uM4mSboU5y6p8S5DzMTVEsJZrawi+BoDNUVBa2DhJqQYUFvMDfgU062LQ== + +"@solidity-parser/parser@^0.14.0", "@solidity-parser/parser@^0.14.1": + version "0.14.1" + resolved "https://registry.npmjs.org/@solidity-parser/parser/-/parser-0.14.1.tgz" + integrity sha512-eLjj2L6AuQjBB6s/ibwCAc0DwrR5Ge+ys+wgWo+bviU7fV2nTMQhU63CGaDKXg9iTmMxwhkyoggdIR7ZGRfMgw== + dependencies: + antlr4ts "^0.5.0-alpha.4" + +"@sushiswap/core-sdk@^1.0.0-canary.34": + version "1.0.0-canary.34" + resolved "https://registry.yarnpkg.com/@sushiswap/core-sdk/-/core-sdk-1.0.0-canary.34.tgz#492dd13861c33c9ce1d076e9c6c5d24047474522" + integrity sha512-fQ8eGWVE0eT393mh4k/t95HDopMdJhmDXU2dOvo/3zZ7+R6qBOKVaw4e2CgtO3ZICN1B3KirzfrXBGK2JkquMw== + dependencies: + "@ethersproject/address" "^5.4.0" + "@ethersproject/bignumber" "^5.4.0" + "@ethersproject/providers" "^5.4.0" + "@ethersproject/solidity" "^5.4.0" + big.js "^6.1.1" + decimal.js-light "^2.5.0" + jsbi "^4.1.0" + tiny-invariant "^1.1.0" + tiny-warning "^1.0.0" + toformat "^2.0.0" + +"@sushiswap/core@^1.4.2": + version "1.4.2" + resolved "https://registry.yarnpkg.com/@sushiswap/core/-/core-1.4.2.tgz#065a6613f842ab7ac6d12878072b59327bffa296" + integrity sha512-Khd2i6Bob9uk7dCgVkhUioEoxRP28m6aj25MegAHvnJyxZPVzZDhxSkeL6wdv5MeAp2DwHkYqUq03KDfVTTP4Q== + +"@szmarczak/http-timer@^1.1.2": + version "1.1.2" + resolved "https://registry.npmjs.org/@szmarczak/http-timer/-/http-timer-1.1.2.tgz" + integrity sha512-XIB2XbzHTN6ieIjfIMV9hlVcfPU26s2vafYWQcZHWXHOxiaRZYEDKEwdl129Zyg50+foYV2jCgtrqSA6qNuNSA== + dependencies: + defer-to-connect "^1.0.1" + +"@tenderly/hardhat-tenderly@^1.0.15": + version "1.0.15" + resolved "https://registry.yarnpkg.com/@tenderly/hardhat-tenderly/-/hardhat-tenderly-1.0.15.tgz#6982e4d17641b235c0aea3746253d468c7d98454" + integrity sha512-zkv+VC/6jx/qCJQ0/IhvP7giumi/gE9gftLUJwaLLbvmWImnM2FS4yGkmVy/NAR1nRA5ucMNQ9laZIXr82pVLQ== + dependencies: + axios "^0.21.1" + fs-extra "^9.0.1" + js-yaml "^3.14.0" + +"@truffle/error@^0.1.0": + version "0.1.0" + resolved "https://registry.npmjs.org/@truffle/error/-/error-0.1.0.tgz" + integrity sha512-RbUfp5VreNhsa2Q4YbBjz18rOQI909pG32bghl1hulO7IpvcqTS+C3Ge5cNbiWQ1WGzy1wIeKLW0tmQtHFB7qg== + +"@truffle/interface-adapter@^0.5.16": + version "0.5.16" + resolved "https://registry.npmjs.org/@truffle/interface-adapter/-/interface-adapter-0.5.16.tgz" + integrity sha512-4L8/TtFSe9eW4KWeXAvi3RrD0rImbLeYB4axPLOCAitUEDCTB/iJjZ1cMkC85LbO9mwz5/AjP0i37YO10rging== + dependencies: + bn.js "^5.1.3" + ethers "^4.0.32" + web3 "1.5.3" + +"@truffle/provider@^0.2.24": + version "0.2.54" + resolved "https://registry.npmjs.org/@truffle/provider/-/provider-0.2.54.tgz" + integrity sha512-BW2bb6p7dAipUCHlRDMSswFqessXkIb8tHVRVkm6KAENIor0F4UCCPlxIzrM/ShRQ1O16jZ+0cxLMwiRWTWdLg== + dependencies: + "@truffle/error" "^0.1.0" + "@truffle/interface-adapter" "^0.5.16" + web3 "1.5.3" + +"@tsconfig/node10@^1.0.7": + version "1.0.8" + resolved "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.8.tgz" + integrity sha512-6XFfSQmMgq0CFLY1MslA/CPUfhIL919M1rMsa5lP2P097N2Wd1sSX0tx1u4olM16fLNhtHZpRhedZJphNJqmZg== + +"@tsconfig/node12@^1.0.7": + version "1.0.9" + resolved "https://registry.npmjs.org/@tsconfig/node12/-/node12-1.0.9.tgz" + integrity sha512-/yBMcem+fbvhSREH+s14YJi18sp7J9jpuhYByADT2rypfajMZZN4WQ6zBGgBKp53NKmqI36wFYDb3yaMPurITw== + +"@tsconfig/node14@^1.0.0": + version "1.0.1" + resolved "https://registry.npmjs.org/@tsconfig/node14/-/node14-1.0.1.tgz" + integrity sha512-509r2+yARFfHHE7T6Puu2jjkoycftovhXRqW328PDXTVGKihlb1P8Z9mMZH04ebyajfRY7dedfGynlrFHJUQCg== + +"@tsconfig/node16@^1.0.2": + version "1.0.2" + resolved "https://registry.npmjs.org/@tsconfig/node16/-/node16-1.0.2.tgz" + integrity sha512-eZxlbI8GZscaGS7kkc/trHTT5xgrjH3/1n2JDwusC9iahPKWMRvRjJSAN5mCXviuTGQ/lHnhvv8Q1YTpnfz9gA== + +"@typechain/ethers-v5@^10.0.0": + version "10.0.0" + resolved "https://registry.npmjs.org/@typechain/ethers-v5/-/ethers-v5-10.0.0.tgz" + integrity sha512-Kot7fwAqnH96ZbI8xrRgj5Kpv9yCEdjo7mxRqrH7bYpEgijT5MmuOo8IVsdhOu7Uog4ONg7k/d5UdbAtTKUgsA== + dependencies: + lodash "^4.17.15" + ts-essentials "^7.0.1" + +"@typechain/ethers-v5@^2.0.0": + version "2.0.0" + resolved "https://registry.npmjs.org/@typechain/ethers-v5/-/ethers-v5-2.0.0.tgz" + integrity sha512-0xdCkyGOzdqh4h5JSf+zoWx85IusEjDcPIwNEHP8mrWSnCae4rvrqB+/gtpdNfX7zjlFlZiMeePn2r63EI3Lrw== + dependencies: + ethers "^5.0.2" + +"@typechain/hardhat@^6.0.0": + version "6.0.0" + resolved "https://registry.npmjs.org/@typechain/hardhat/-/hardhat-6.0.0.tgz" + integrity sha512-AnhwODKHxx3+st5uc1j2NQh79Lv2OuvDQe4dKn8ZxhqYsAsTPnHTLBeI8KPZ+mfdE7v13D2QYssRTIkkGhK35A== + dependencies: + fs-extra "^9.1.0" + lodash "^4.17.15" + +"@types/abstract-leveldown@*": + version "7.2.0" + resolved "https://registry.npmjs.org/@types/abstract-leveldown/-/abstract-leveldown-7.2.0.tgz" + integrity sha512-q5veSX6zjUy/DlDhR4Y4cU0k2Ar+DT2LUraP00T19WLmTO6Se1djepCCaqU6nQrwcJ5Hyo/CWqxTzrrFg8eqbQ== + +"@types/bn.js@*", "@types/bn.js@^5.1.0": + version "5.1.0" + resolved "https://registry.npmjs.org/@types/bn.js/-/bn.js-5.1.0.tgz" + integrity sha512-QSSVYj7pYFN49kW77o2s9xTCwZ8F2xLbjLLSEVh8D2F4JUhZtPAGOFLTD+ffqksBx/u4cE/KImFjyhqCjn/LIA== + dependencies: + "@types/node" "*" + +"@types/bn.js@^4.11.3", "@types/bn.js@^4.11.5": + version "4.11.6" + resolved "https://registry.npmjs.org/@types/bn.js/-/bn.js-4.11.6.tgz" + integrity sha512-pqr857jrp2kPuO9uRjZ3PwnJTjoQy+fcdxvBTvHm6dkmEL9q+hDD/2j/0ELOBPtPnS8LjCX0gI9nbl8lVkadpg== + dependencies: + "@types/node" "*" + +"@types/chai@*", "@types/chai@^4.3.0": + version "4.3.1" + resolved "https://registry.npmjs.org/@types/chai/-/chai-4.3.1.tgz" + integrity sha512-/zPMqDkzSZ8t3VtxOa4KPq7uzzW978M9Tvh+j7GHKuo6k6GTLxPJ4J5gE5cjfJ26pnXst0N5Hax8Sr0T2Mi9zQ== + +"@types/concat-stream@^1.6.0": + version "1.6.1" + resolved "https://registry.npmjs.org/@types/concat-stream/-/concat-stream-1.6.1.tgz" + integrity sha512-eHE4cQPoj6ngxBZMvVf6Hw7Mh4jMW4U9lpGmS5GBPB9RYxlFg+CHaVN7ErNY4W9XfLIEn20b4VDYaIrbq0q4uA== + dependencies: + "@types/node" "*" + +"@types/form-data@0.0.33": + version "0.0.33" + resolved "https://registry.npmjs.org/@types/form-data/-/form-data-0.0.33.tgz" + integrity sha1-yayFsqX9GENbjIXZ7LUObWyJP/g= + dependencies: + "@types/node" "*" + +"@types/glob@^7.1.1": + version "7.2.0" + resolved "https://registry.npmjs.org/@types/glob/-/glob-7.2.0.tgz" + integrity sha512-ZUxbzKl0IfJILTS6t7ip5fQQM/J3TJYubDm3nMbgubNNYS62eXeUpoLUC8/7fJNiFYHTrGPQn7hspDUzIHX3UA== + dependencies: + "@types/minimatch" "*" + "@types/node" "*" + +"@types/json-schema@^7.0.9": + version "7.0.11" + resolved "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.11.tgz" + integrity sha512-wOuvG1SN4Us4rez+tylwwwCV1psiNVOkJeM3AUWUNWg/jDQY2+HE/444y5gc+jBmRqASOm2Oeh5c1axHobwRKQ== + +"@types/json5@^0.0.29": + version "0.0.29" + resolved "https://registry.npmjs.org/@types/json5/-/json5-0.0.29.tgz" + integrity sha1-7ihweulOEdK4J7y+UnC86n8+ce4= + +"@types/level-errors@*": + version "3.0.0" + resolved "https://registry.npmjs.org/@types/level-errors/-/level-errors-3.0.0.tgz" + integrity sha512-/lMtoq/Cf/2DVOm6zE6ORyOM+3ZVm/BvzEZVxUhf6bgh8ZHglXlBqxbxSlJeVp8FCbD3IVvk/VbsaNmDjrQvqQ== + +"@types/levelup@^4.3.0": + version "4.3.3" + resolved "https://registry.npmjs.org/@types/levelup/-/levelup-4.3.3.tgz" + integrity sha512-K+OTIjJcZHVlZQN1HmU64VtrC0jC3dXWQozuEIR9zVvltIk90zaGPM2AgT+fIkChpzHhFE3YnvFLCbLtzAmexA== + dependencies: + "@types/abstract-leveldown" "*" + "@types/level-errors" "*" + "@types/node" "*" + +"@types/lru-cache@^5.1.0": + version "5.1.1" + resolved "https://registry.npmjs.org/@types/lru-cache/-/lru-cache-5.1.1.tgz" + integrity sha512-ssE3Vlrys7sdIzs5LOxCzTVMsU7i9oa/IaW92wF32JFb3CVczqOkru2xspuKczHEbG3nvmPY7IFqVmGGHdNbYw== + +"@types/minimatch@*": + version "3.0.5" + resolved "https://registry.npmjs.org/@types/minimatch/-/minimatch-3.0.5.tgz" + integrity sha512-Klz949h02Gz2uZCMGwDUSDS1YBlTdDDgbWHi+81l29tQALUtvz4rAYi5uoVhE5Lagoq6DeqAUlbrHvW/mXDgdQ== + +"@types/mkdirp@^0.5.2": + version "0.5.2" + resolved "https://registry.npmjs.org/@types/mkdirp/-/mkdirp-0.5.2.tgz" + integrity sha512-U5icWpv7YnZYGsN4/cmh3WD2onMY0aJIiTE6+51TwJCttdHvtCYmkBNOobHlXwrJRL0nkH9jH4kD+1FAdMN4Tg== + dependencies: + "@types/node" "*" + +"@types/mocha@^9.0.0": + version "9.1.1" + resolved "https://registry.npmjs.org/@types/mocha/-/mocha-9.1.1.tgz" + integrity sha512-Z61JK7DKDtdKTWwLeElSEBcWGRLY8g95ic5FoQqI9CMx0ns/Ghep3B4DfcEimiKMvtamNVULVNKEsiwV3aQmXw== + +"@types/node-fetch@^2.5.5": + version "2.6.1" + resolved "https://registry.npmjs.org/@types/node-fetch/-/node-fetch-2.6.1.tgz" + integrity sha512-oMqjURCaxoSIsHSr1E47QHzbmzNR5rK8McHuNb11BOM9cHcIK3Avy0s/b2JlXHoQGTYS3NsvWzV1M0iK7l0wbA== + dependencies: + "@types/node" "*" + form-data "^3.0.0" + +"@types/node@*", "@types/node@^17.0.8": + version "17.0.30" + resolved "https://registry.npmjs.org/@types/node/-/node-17.0.30.tgz" + integrity sha512-oNBIZjIqyHYP8VCNAV9uEytXVeXG2oR0w9lgAXro20eugRQfY002qr3CUl6BAe+Yf/z3CRjPdz27Pu6WWtuSRw== + +"@types/node@^10.0.3": + version "10.17.60" + resolved "https://registry.npmjs.org/@types/node/-/node-10.17.60.tgz" + integrity sha512-F0KIgDJfy2nA3zMLmWGKxcH2ZVEtCZXHHdOQs2gSaQ27+lNeEfGxzkIw90aXswATX7AZ33tahPbzy6KAfUreVw== + +"@types/node@^12.12.6": + version "12.20.50" + resolved "https://registry.npmjs.org/@types/node/-/node-12.20.50.tgz" + integrity sha512-+9axpWx2b2JCVovr7Ilgt96uc6C1zBKOQMpGtRbWT9IoR/8ue32GGMfGA4woP8QyP2gBs6GQWEVM3tCybGCxDA== + +"@types/node@^8.0.0": + version "8.10.66" + resolved "https://registry.npmjs.org/@types/node/-/node-8.10.66.tgz" + integrity sha512-tktOkFUA4kXx2hhhrB8bIFb5TbwzS4uOhKEmwiD+NoiL0qtP2OQ9mFldbgD4dV1djrlBYP6eBuQZiWjuHUpqFw== + +"@types/pbkdf2@^3.0.0": + version "3.1.0" + resolved "https://registry.npmjs.org/@types/pbkdf2/-/pbkdf2-3.1.0.tgz" + integrity sha512-Cf63Rv7jCQ0LaL8tNXmEyqTHuIJxRdlS5vMh1mj5voN4+QFhVZnlZruezqpWYDiJ8UTzhP0VmeLXCmBk66YrMQ== + dependencies: + "@types/node" "*" + +"@types/prettier@^2.1.1": + version "2.6.0" + resolved "https://registry.npmjs.org/@types/prettier/-/prettier-2.6.0.tgz" + integrity sha512-G/AdOadiZhnJp0jXCaBQU449W2h716OW/EoXeYkCytxKL06X1WCXB4DZpp8TpZ8eyIJVS1cw4lrlkkSYU21cDw== + +"@types/qs@^6.2.31", "@types/qs@^6.9.7": + version "6.9.7" + resolved "https://registry.npmjs.org/@types/qs/-/qs-6.9.7.tgz" + integrity sha512-FGa1F62FT09qcrueBA6qYTrJPVDzah9a+493+o2PCXsesWHIn27G98TsSMs3WPNbZIEj4+VJf6saSFpvD+3Zsw== + +"@types/readline-sync@^1.4.4": + version "1.4.4" + resolved "https://registry.yarnpkg.com/@types/readline-sync/-/readline-sync-1.4.4.tgz#8568292efe4ddd94d0ccee958b29cc3f4e0ea140" + integrity sha512-cFjVIoiamX7U6zkO2VPvXyTxbFDdiRo902IarJuPVxBhpDnXhwSaVE86ip+SCuyWBbEioKCkT4C88RNTxBM1Dw== + +"@types/resolve@^0.0.8": + version "0.0.8" + resolved "https://registry.npmjs.org/@types/resolve/-/resolve-0.0.8.tgz" + integrity sha512-auApPaJf3NPfe18hSoJkp8EbZzer2ISk7o8mCC3M9he/a04+gbMF97NkpD2S8riMGvm4BMRI59/SZQSaLTKpsQ== + dependencies: + "@types/node" "*" + +"@types/secp256k1@^4.0.1": + version "4.0.3" + resolved "https://registry.npmjs.org/@types/secp256k1/-/secp256k1-4.0.3.tgz" + integrity sha512-Da66lEIFeIz9ltsdMZcpQvmrmmoqrfju8pm1BH8WbYjZSwUgCwXLb9C+9XYogwBITnbsSaMdVPb2ekf7TV+03w== + dependencies: + "@types/node" "*" + +"@types/sinon-chai@^3.2.3": + version "3.2.8" + resolved "https://registry.npmjs.org/@types/sinon-chai/-/sinon-chai-3.2.8.tgz" + integrity sha512-d4ImIQbT/rKMG8+AXpmcan5T2/PNeSjrYhvkwet6z0p8kzYtfgA32xzOBlbU0yqJfq+/0Ml805iFoODO0LP5/g== + dependencies: + "@types/chai" "*" + "@types/sinon" "*" + +"@types/sinon@*": + version "10.0.11" + resolved "https://registry.npmjs.org/@types/sinon/-/sinon-10.0.11.tgz" + integrity sha512-dmZsHlBsKUtBpHriNjlK0ndlvEh8dcb9uV9Afsbt89QIyydpC7NcR+nWlAhASfy3GHnxTl4FX/aKE7XZUt/B4g== + dependencies: + "@types/sinonjs__fake-timers" "*" + +"@types/sinonjs__fake-timers@*": + version "8.1.2" + resolved "https://registry.npmjs.org/@types/sinonjs__fake-timers/-/sinonjs__fake-timers-8.1.2.tgz" + integrity sha512-9GcLXF0/v3t80caGs5p2rRfkB+a8VBGLJZVih6CNFkx8IZ994wiKKLSRs9nuFwk1HevWs/1mnUmkApGrSGsShA== + +"@types/underscore@*": + version "1.11.4" + resolved "https://registry.npmjs.org/@types/underscore/-/underscore-1.11.4.tgz" + integrity sha512-uO4CD2ELOjw8tasUrAhvnn2W4A0ZECOvMjCivJr4gA9pGgjv+qxKWY9GLTMVEK8ej85BxQOocUyE7hImmSQYcg== + +"@types/web3@1.0.19": + version "1.0.19" + resolved "https://registry.npmjs.org/@types/web3/-/web3-1.0.19.tgz" + integrity sha512-fhZ9DyvDYDwHZUp5/STa9XW2re0E8GxoioYJ4pEUZ13YHpApSagixj7IAdoYH5uAK+UalGq6Ml8LYzmgRA/q+A== + dependencies: + "@types/bn.js" "*" + "@types/underscore" "*" + +"@typescript-eslint/eslint-plugin@^5.9.1": + version "5.21.0" + resolved "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.21.0.tgz" + integrity sha512-fTU85q8v5ZLpoZEyn/u1S2qrFOhi33Edo2CZ0+q1gDaWWm0JuPh3bgOyU8lM0edIEYgKLDkPFiZX2MOupgjlyg== + dependencies: + "@typescript-eslint/scope-manager" "5.21.0" + "@typescript-eslint/type-utils" "5.21.0" + "@typescript-eslint/utils" "5.21.0" + debug "^4.3.2" + functional-red-black-tree "^1.0.1" + ignore "^5.1.8" + regexpp "^3.2.0" + semver "^7.3.5" + tsutils "^3.21.0" + +"@typescript-eslint/parser@^5.9.1": + version "5.21.0" + resolved "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.21.0.tgz" + integrity sha512-8RUwTO77hstXUr3pZoWZbRQUxXcSXafZ8/5gpnQCfXvgmP9gpNlRGlWzvfbEQ14TLjmtU8eGnONkff8U2ui2Eg== + dependencies: + "@typescript-eslint/scope-manager" "5.21.0" + "@typescript-eslint/types" "5.21.0" + "@typescript-eslint/typescript-estree" "5.21.0" + debug "^4.3.2" + +"@typescript-eslint/scope-manager@5.21.0": + version "5.21.0" + resolved "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.21.0.tgz" + integrity sha512-XTX0g0IhvzcH/e3393SvjRCfYQxgxtYzL3UREteUneo72EFlt7UNoiYnikUtmGVobTbhUDByhJ4xRBNe+34kOQ== + dependencies: + "@typescript-eslint/types" "5.21.0" + "@typescript-eslint/visitor-keys" "5.21.0" + +"@typescript-eslint/type-utils@5.21.0": + version "5.21.0" + resolved "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-5.21.0.tgz" + integrity sha512-MxmLZj0tkGlkcZCSE17ORaHl8Th3JQwBzyXL/uvC6sNmu128LsgjTX0NIzy+wdH2J7Pd02GN8FaoudJntFvSOw== + dependencies: + "@typescript-eslint/utils" "5.21.0" + debug "^4.3.2" + tsutils "^3.21.0" + +"@typescript-eslint/types@5.21.0": + version "5.21.0" + resolved "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.21.0.tgz" + integrity sha512-XnOOo5Wc2cBlq8Lh5WNvAgHzpjnEzxn4CJBwGkcau7b/tZ556qrWXQz4DJyChYg8JZAD06kczrdgFPpEQZfDsA== + +"@typescript-eslint/typescript-estree@5.21.0": + version "5.21.0" + resolved "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-5.21.0.tgz" + integrity sha512-Y8Y2T2FNvm08qlcoSMoNchh9y2Uj3QmjtwNMdRQkcFG7Muz//wfJBGBxh8R7HAGQFpgYpdHqUpEoPQk+q9Kjfg== + dependencies: + "@typescript-eslint/types" "5.21.0" + "@typescript-eslint/visitor-keys" "5.21.0" + debug "^4.3.2" + globby "^11.0.4" + is-glob "^4.0.3" + semver "^7.3.5" + tsutils "^3.21.0" + +"@typescript-eslint/utils@5.21.0": + version "5.21.0" + resolved "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-5.21.0.tgz" + integrity sha512-q/emogbND9wry7zxy7VYri+7ydawo2HDZhRZ5k6yggIvXa7PvBbAAZ4PFH/oZLem72ezC4Pr63rJvDK/sTlL8Q== + dependencies: + "@types/json-schema" "^7.0.9" + "@typescript-eslint/scope-manager" "5.21.0" + "@typescript-eslint/types" "5.21.0" + "@typescript-eslint/typescript-estree" "5.21.0" + eslint-scope "^5.1.1" + eslint-utils "^3.0.0" + +"@typescript-eslint/visitor-keys@5.21.0": + version "5.21.0" + resolved "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.21.0.tgz" + integrity sha512-SX8jNN+iHqAF0riZQMkm7e8+POXa/fXw5cxL+gjpyP+FI+JVNhii53EmQgDAfDcBpFekYSlO0fGytMQwRiMQCA== + dependencies: + "@typescript-eslint/types" "5.21.0" + eslint-visitor-keys "^3.0.0" + +"@ungap/promise-all-settled@1.1.2": + version "1.1.2" + resolved "https://registry.npmjs.org/@ungap/promise-all-settled/-/promise-all-settled-1.1.2.tgz" + integrity sha512-sL/cEvJWAnClXw0wHk85/2L0G6Sj8UB0Ctc1TEMbKSsmpRosqhwj9gWgFRZSrBr2f9tiXISwNhCPmlfqUqyb9Q== + +"@yarnpkg/lockfile@^1.1.0": + version "1.1.0" + resolved "https://registry.npmjs.org/@yarnpkg/lockfile/-/lockfile-1.1.0.tgz" + integrity sha512-GpSwvyXOcOOlV70vbnzjj4fW5xW/FdUF6nQEt1ENy7m4ZCczi1+/buVUPAqmGfqznsORNFzUMjctTIp8a9tuCQ== + +abbrev@1: + version "1.1.1" + resolved "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz" + integrity sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q== + +abbrev@1.0.x: + version "1.0.9" + resolved "https://registry.npmjs.org/abbrev/-/abbrev-1.0.9.tgz" + integrity sha1-kbR5JYinc4wl813W9jdSovh3YTU= + +abort-controller@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz" + integrity sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg== + dependencies: + event-target-shim "^5.0.0" + +abstract-leveldown@3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/abstract-leveldown/-/abstract-leveldown-3.0.0.tgz" + integrity sha512-KUWx9UWGQD12zsmLNj64/pndaz4iJh/Pj7nopgkfDG6RlCcbMZvT6+9l7dchK4idog2Is8VdC/PvNbFuFmalIQ== + dependencies: + xtend "~4.0.0" + +abstract-leveldown@^2.4.1, abstract-leveldown@~2.7.1: + version "2.7.2" + resolved "https://registry.npmjs.org/abstract-leveldown/-/abstract-leveldown-2.7.2.tgz" + integrity sha512-+OVvxH2rHVEhWLdbudP6p0+dNMXu8JA1CbhP19T8paTYAcX7oJ4OVjT+ZUVpv7mITxXHqDMej+GdqXBmXkw09w== + dependencies: + xtend "~4.0.0" + +abstract-leveldown@^5.0.0, abstract-leveldown@~5.0.0: + version "5.0.0" + resolved "https://registry.npmjs.org/abstract-leveldown/-/abstract-leveldown-5.0.0.tgz" + integrity sha512-5mU5P1gXtsMIXg65/rsYGsi93+MlogXZ9FA8JnwKurHQg64bfXwGYVdVdijNTVNOlAsuIiOwHdvFFD5JqCJQ7A== + dependencies: + xtend "~4.0.0" + +abstract-leveldown@^6.2.1: + version "6.3.0" + resolved "https://registry.npmjs.org/abstract-leveldown/-/abstract-leveldown-6.3.0.tgz" + integrity sha512-TU5nlYgta8YrBMNpc9FwQzRbiXsj49gsALsXadbGHt9CROPzX5fB0rWDR5mtdpOOKa5XqRFpbj1QroPAoPzVjQ== + dependencies: + buffer "^5.5.0" + immediate "^3.2.3" + level-concat-iterator "~2.0.0" + level-supports "~1.0.0" + xtend "~4.0.0" + +abstract-leveldown@~2.6.0: + version "2.6.3" + resolved "https://registry.npmjs.org/abstract-leveldown/-/abstract-leveldown-2.6.3.tgz" + integrity sha512-2++wDf/DYqkPR3o5tbfdhF96EfMApo1GpPfzOsR/ZYXdkSmELlvOOEAl9iKkRsktMPHdGjO4rtkBpf2I7TiTeA== + dependencies: + xtend "~4.0.0" + +abstract-leveldown@~6.2.1: + version "6.2.3" + resolved "https://registry.npmjs.org/abstract-leveldown/-/abstract-leveldown-6.2.3.tgz" + integrity sha512-BsLm5vFMRUrrLeCcRc+G0t2qOaTzpoJQLOubq2XM72eNpjF5UdU5o/5NvlNhx95XHcAvcl8OMXr4mlg/fRgUXQ== + dependencies: + buffer "^5.5.0" + immediate "^3.2.3" + level-concat-iterator "~2.0.0" + level-supports "~1.0.0" + xtend "~4.0.0" + +accepts@~1.3.8: + version "1.3.8" + resolved "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz" + integrity sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw== + dependencies: + mime-types "~2.1.34" + negotiator "0.6.3" + +acorn-jsx@^5.0.0, acorn-jsx@^5.3.1: + version "5.3.2" + resolved "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz" + integrity sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ== + +acorn-walk@^8.1.1: + version "8.2.0" + resolved "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.2.0.tgz" + integrity sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA== + +acorn@^6.0.7: + version "6.4.2" + resolved "https://registry.npmjs.org/acorn/-/acorn-6.4.2.tgz" + integrity sha512-XtGIhXwF8YM8bJhGxG5kXgjkEuNGLTkoYqVE+KMR+aspr4KGYmKYg7yUe3KghyQ9yheNwLnjmzh/7+gfDBmHCQ== + +acorn@^8.4.1, acorn@^8.7.0: + version "8.7.1" + resolved "https://registry.npmjs.org/acorn/-/acorn-8.7.1.tgz" + integrity sha512-Xx54uLJQZ19lKygFXOWsscKUbsBZW0CPykPhVQdhIeIwrbPmJzqeASDInc8nKBnp/JT6igTs82qPXz069H8I/A== + +address@^1.0.1: + version "1.2.0" + resolved "https://registry.npmjs.org/address/-/address-1.2.0.tgz" + integrity sha512-tNEZYz5G/zYunxFm7sfhAxkXEuLj3K6BKwv6ZURlsF6yiUQ65z0Q2wZW9L5cPUl9ocofGvXOdFYbFHp0+6MOig== + +adm-zip@^0.4.16: + version "0.4.16" + resolved "https://registry.npmjs.org/adm-zip/-/adm-zip-0.4.16.tgz" + integrity sha512-TFi4HBKSGfIKsK5YCkKaaFG2m4PEDyViZmEwof3MTIgzimHLto6muaHVpbrljdIvIrFZzEq/p4nafOeLcYegrg== + +aes-js@3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/aes-js/-/aes-js-3.0.0.tgz" + integrity sha1-4h3xCtbCBTKVvLuNq0Cwnb6ofk0= + +aes-js@^3.1.1: + version "3.1.2" + resolved "https://registry.npmjs.org/aes-js/-/aes-js-3.1.2.tgz" + integrity sha512-e5pEa2kBnBOgR4Y/p20pskXI74UEz7de8ZGVo58asOtvSVG5YAbJeELPZxOmt+Bnz3rX753YKhfIn4X4l1PPRQ== + +agent-base@6: + version "6.0.2" + resolved "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz" + integrity sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ== + dependencies: + debug "4" + +aggregate-error@^3.0.0: + version "3.1.0" + resolved "https://registry.npmjs.org/aggregate-error/-/aggregate-error-3.1.0.tgz" + integrity sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA== + dependencies: + clean-stack "^2.0.0" + indent-string "^4.0.0" + +ajv@^6.10.0, ajv@^6.10.2, ajv@^6.12.3, ajv@^6.12.4, ajv@^6.6.1, ajv@^6.9.1: + version "6.12.6" + resolved "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz" + integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g== + dependencies: + fast-deep-equal "^3.1.1" + fast-json-stable-stringify "^2.0.0" + json-schema-traverse "^0.4.1" + uri-js "^4.2.2" + +ajv@^8.0.1: + version "8.11.0" + resolved "https://registry.yarnpkg.com/ajv/-/ajv-8.11.0.tgz#977e91dd96ca669f54a11e23e378e33b884a565f" + integrity sha512-wGgprdCvMalC0BztXvitD2hC04YffAvtsUn93JbGXYLAtCUO4xd17mCCZQxUOItiBwZvJScWo8NIvQMQ71rdpg== + dependencies: + fast-deep-equal "^3.1.1" + json-schema-traverse "^1.0.0" + require-from-string "^2.0.2" + uri-js "^4.2.2" + +amdefine@>=0.0.4: + version "1.0.1" + resolved "https://registry.npmjs.org/amdefine/-/amdefine-1.0.1.tgz" + integrity sha1-SlKCrBZHKek2Gbz9OtFR+BfOkfU= + +ansi-colors@3.2.3: + version "3.2.3" + resolved "https://registry.npmjs.org/ansi-colors/-/ansi-colors-3.2.3.tgz" + integrity sha512-LEHHyuhlPY3TmuUYMh2oz89lTShfvgbmzaBcxve9t/9Wuy7Dwf4yoAKcND7KFT1HAQfqZ12qtc+DUrBMeKF9nw== + +ansi-colors@4.1.1, ansi-colors@^4.1.1: + version "4.1.1" + resolved "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.1.tgz" + integrity sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA== + +ansi-escapes@^3.2.0: + version "3.2.0" + resolved "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-3.2.0.tgz" + integrity sha512-cBhpre4ma+U0T1oM5fXg7Dy1Jw7zzwv7lt/GoCpr+hDQJoYnKVPLL4dCvSEFMmQurOQvSrwT7SL/DAlhBI97RQ== + +ansi-escapes@^4.3.0: + version "4.3.2" + resolved "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz" + integrity sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ== + dependencies: + type-fest "^0.21.3" + +ansi-regex@^2.0.0: + version "2.1.1" + resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz" + integrity sha1-w7M6te42DYbg5ijwRorn7yfWVN8= + +ansi-regex@^3.0.0: + version "3.0.1" + resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.1.tgz" + integrity sha512-+O9Jct8wf++lXxxFc4hc8LsjaSq0HFzzL7cVsw8pRDIPdjKD2mT4ytDZlLuSBZ4cLKZFXIrMGO7DbQCtMJJMKw== + +ansi-regex@^4.1.0: + version "4.1.1" + resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.1.tgz" + integrity sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g== + +ansi-regex@^5.0.1: + version "5.0.1" + resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz" + integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ== + +ansi-regex@^6.0.1: + version "6.0.1" + resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.0.1.tgz" + integrity sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA== + +ansi-styles@^2.2.1: + version "2.2.1" + resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-2.2.1.tgz" + integrity sha1-tDLdM1i2NM914eRmQ2gkBTPB3b4= + +ansi-styles@^3.2.0, ansi-styles@^3.2.1: + version "3.2.1" + resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz" + integrity sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA== + dependencies: + color-convert "^1.9.0" + +ansi-styles@^4.0.0, ansi-styles@^4.1.0: + version "4.3.0" + resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz" + integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg== + dependencies: + color-convert "^2.0.1" + +ansi-styles@^6.0.0: + version "6.1.0" + resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.1.0.tgz" + integrity sha512-VbqNsoz55SYGczauuup0MFUyXNQviSpFTj1RQtFzmQLk18qbVSpTFFGMT293rmDaQuKCT6InmbuEyUne4mTuxQ== + +antlr4@4.7.1: + version "4.7.1" + resolved "https://registry.npmjs.org/antlr4/-/antlr4-4.7.1.tgz" + integrity sha512-haHyTW7Y9joE5MVs37P2lNYfU2RWBLfcRDD8OWldcdZm5TiCE91B5Xl1oWSwiDUSd4rlExpt2pu1fksYQjRBYQ== + +antlr4ts@^0.5.0-alpha.4: + version "0.5.0-alpha.4" + resolved "https://registry.npmjs.org/antlr4ts/-/antlr4ts-0.5.0-alpha.4.tgz" + integrity sha512-WPQDt1B74OfPv/IMS2ekXAKkTZIHl88uMetg6q3OTqgFxZ/dxDXI0EWLyZid/1Pe6hTftyg5N7gel5wNAGxXyQ== + +anymatch@~3.1.1, anymatch@~3.1.2: + version "3.1.2" + resolved "https://registry.npmjs.org/anymatch/-/anymatch-3.1.2.tgz" + integrity sha512-P43ePfOAIupkguHUycrc4qJ9kz8ZiuOUijaETwX7THt0Y/GNK7v0aa8rY816xWjZ7rJdA5XdMcpVFTKMq+RvWg== + dependencies: + normalize-path "^3.0.0" + picomatch "^2.0.4" + +arg@^4.1.0: + version "4.1.3" + resolved "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz" + integrity sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA== + +argparse@^1.0.7: + version "1.0.10" + resolved "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz" + integrity sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg== + dependencies: + sprintf-js "~1.0.2" + +argparse@^2.0.1: + version "2.0.1" + resolved "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz" + integrity sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q== + +arr-diff@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/arr-diff/-/arr-diff-4.0.0.tgz" + integrity sha1-1kYQdP6/7HHn4VI1dhoyml3HxSA= + +arr-flatten@^1.1.0: + version "1.1.0" + resolved "https://registry.npmjs.org/arr-flatten/-/arr-flatten-1.1.0.tgz" + integrity sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg== + +arr-union@^3.1.0: + version "3.1.0" + resolved "https://registry.npmjs.org/arr-union/-/arr-union-3.1.0.tgz" + integrity sha1-45sJrqne+Gao8gbiiK9jkZuuOcQ= + +array-back@^1.0.3, array-back@^1.0.4: + version "1.0.4" + resolved "https://registry.npmjs.org/array-back/-/array-back-1.0.4.tgz" + integrity sha1-ZEun8JX3/898Q7Xw3DnTwfA8Bjs= + dependencies: + typical "^2.6.0" + +array-back@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/array-back/-/array-back-2.0.0.tgz" + integrity sha512-eJv4pLLufP3g5kcZry0j6WXpIbzYw9GUB4mVJZno9wfwiBxbizTnHCw3VJb07cBihbFX48Y7oSrW9y+gt4glyw== + dependencies: + typical "^2.6.1" + +array-back@^3.0.1, array-back@^3.1.0: + version "3.1.0" + resolved "https://registry.npmjs.org/array-back/-/array-back-3.1.0.tgz" + integrity sha512-TkuxA4UCOvxuDK6NZYXCalszEzj+TLszyASooky+i742l9TqsOdYCMJJupxRic61hwquNtppB3hgcuq9SVSH1Q== + +array-back@^4.0.1, array-back@^4.0.2: + version "4.0.2" + resolved "https://registry.npmjs.org/array-back/-/array-back-4.0.2.tgz" + integrity sha512-NbdMezxqf94cnNfWLL7V/im0Ub+Anbb0IoZhvzie8+4HJ4nMQuzHuy49FkGYCJK2yAloZ3meiB6AVMClbrI1vg== + +array-flatten@1.1.1: + version "1.1.1" + resolved "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz" + integrity sha1-ml9pkFGx5wczKPKgCJaLZOopVdI= + +array-includes@^3.1.4: + version "3.1.4" + resolved "https://registry.npmjs.org/array-includes/-/array-includes-3.1.4.tgz" + integrity sha512-ZTNSQkmWumEbiHO2GF4GmWxYVTiQyJy2XOTa15sdQSrvKn7l+180egQMqlrMOUMCyLMD7pmyQe4mMDUT6Behrw== + dependencies: + call-bind "^1.0.2" + define-properties "^1.1.3" + es-abstract "^1.19.1" + get-intrinsic "^1.1.1" + is-string "^1.0.7" + +array-union@^2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz" + integrity sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw== + +array-uniq@1.0.3: + version "1.0.3" + resolved "https://registry.npmjs.org/array-uniq/-/array-uniq-1.0.3.tgz" + integrity sha1-r2rId6Jcx/dOBYiUdThY39sk/bY= + +array-unique@^0.3.2: + version "0.3.2" + resolved "https://registry.npmjs.org/array-unique/-/array-unique-0.3.2.tgz" + integrity sha1-qJS3XUvE9s1nnvMkSp/Y9Gri1Cg= + +array.prototype.flat@^1.2.5: + version "1.3.0" + resolved "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.0.tgz" + integrity sha512-12IUEkHsAhA4DY5s0FPgNXIdc8VRSqD9Zp78a5au9abH/SOBrsp082JOWFNTjkMozh8mqcdiKuaLGhPeYztxSw== + dependencies: + call-bind "^1.0.2" + define-properties "^1.1.3" + es-abstract "^1.19.2" + es-shim-unscopables "^1.0.0" + +asap@~2.0.6: + version "2.0.6" + resolved "https://registry.npmjs.org/asap/-/asap-2.0.6.tgz" + integrity sha1-5QNHYR1+aQlDIIu9r+vLwvuGbUY= + +asn1.js@^5.2.0: + version "5.4.1" + resolved "https://registry.npmjs.org/asn1.js/-/asn1.js-5.4.1.tgz" + integrity sha512-+I//4cYPccV8LdmBLiX8CYvf9Sp3vQsrqu2QNXRcrbiWvcx/UdlFiqUJJzxRQxgsZmvhXhn4cSKeSmoFjVdupA== + dependencies: + bn.js "^4.0.0" + inherits "^2.0.1" + minimalistic-assert "^1.0.0" + safer-buffer "^2.1.0" + +asn1@~0.2.3: + version "0.2.6" + resolved "https://registry.npmjs.org/asn1/-/asn1-0.2.6.tgz" + integrity sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ== + dependencies: + safer-buffer "~2.1.0" + +assert-plus@1.0.0, assert-plus@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz" + integrity sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU= + +assertion-error@^1.1.0: + version "1.1.0" + resolved "https://registry.npmjs.org/assertion-error/-/assertion-error-1.1.0.tgz" + integrity sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw== + +assign-symbols@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/assign-symbols/-/assign-symbols-1.0.0.tgz" + integrity sha1-WWZ/QfrdTyDMvCu5a41Pf3jsA2c= + +ast-parents@0.0.1: + version "0.0.1" + resolved "https://registry.npmjs.org/ast-parents/-/ast-parents-0.0.1.tgz" + integrity sha1-UI/Q8F0MSHddnszaLhdEIyYejdM= + +astral-regex@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/astral-regex/-/astral-regex-1.0.0.tgz" + integrity sha512-+Ryf6g3BKoRc7jfp7ad8tM4TtMiaWvbF/1/sQcZPkkS7ag3D5nMBCe2UfOTONtAkaG0tO0ij3C5Lwmf1EiyjHg== + +astral-regex@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/astral-regex/-/astral-regex-2.0.0.tgz" + integrity sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ== + +async-eventemitter@^0.2.2, async-eventemitter@^0.2.4: + version "0.2.4" + resolved "https://registry.npmjs.org/async-eventemitter/-/async-eventemitter-0.2.4.tgz" + integrity sha512-pd20BwL7Yt1zwDFy+8MX8F1+WCT8aQeKj0kQnTrH9WaeRETlRamVhD0JtRPmrV4GfOJ2F9CvdQkZeZhnh2TuHw== + dependencies: + async "^2.4.0" + +async-limiter@~1.0.0: + version "1.0.1" + resolved "https://registry.npmjs.org/async-limiter/-/async-limiter-1.0.1.tgz" + integrity sha512-csOlWGAcRFJaI6m+F2WKdnMKr4HhdhFVBk0H/QbJFMCr+uO2kwohwXQPxw/9OCxp05r5ghVBFSyioixx3gfkNQ== + +async@1.x, async@2.6.2, async@>=2.6.4, async@^1.4.2, async@^2.0.1, async@^2.1.2, async@^2.4.0, async@^2.5.0, async@^2.6.1: + version "3.2.3" + resolved "https://registry.yarnpkg.com/async/-/async-3.2.3.tgz#ac53dafd3f4720ee9e8a160628f18ea91df196c9" + integrity sha512-spZRyzKL5l5BZQrr/6m/SqFdBN0q3OCI0f9rjfBzCMBIP4p75P620rR3gTmaksNOhmzgdxcaxdNfMy6anrbM0g== + +asynckit@^0.4.0: + version "0.4.0" + resolved "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz" + integrity sha1-x57Zf380y48robyXkLzDZkdLS3k= + +at-least-node@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/at-least-node/-/at-least-node-1.0.0.tgz" + integrity sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg== + +atob@^2.1.2: + version "2.1.2" + resolved "https://registry.npmjs.org/atob/-/atob-2.1.2.tgz" + integrity sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg== + +available-typed-arrays@^1.0.5: + version "1.0.5" + resolved "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.5.tgz" + integrity sha512-DMD0KiN46eipeziST1LPP/STfDU0sufISXmjSgvVsoU2tqxctQeASejWcfNtxYKqETM1UxQ8sp2OrSBWpHY6sw== + +aws-sign2@~0.7.0: + version "0.7.0" + resolved "https://registry.npmjs.org/aws-sign2/-/aws-sign2-0.7.0.tgz" + integrity sha1-tG6JCTSpWR8tL2+G1+ap8bP+dqg= + +aws4@^1.8.0: + version "1.11.0" + resolved "https://registry.npmjs.org/aws4/-/aws4-1.11.0.tgz" + integrity sha512-xh1Rl34h6Fi1DC2WWKfxUTVqRsNnr6LsKz2+hfwDxQJWmrx8+c7ylaqBMcHfl1U1r2dsifOvKX3LQuLNZ+XSvA== + +axios@^0.21.1: + version "0.21.4" + resolved "https://registry.yarnpkg.com/axios/-/axios-0.21.4.tgz#c67b90dc0568e5c1cf2b0b858c43ba28e2eda575" + integrity sha512-ut5vewkiu8jjGBdqpM44XxjuCjq9LAKeHVmoVfHVzy8eHgxxq8SbAVQNovDA8mVi05kP0Ea/n/UzcSHcTJQfNg== + dependencies: + follow-redirects "^1.14.0" + +babel-code-frame@^6.26.0: + version "6.26.0" + resolved "https://registry.npmjs.org/babel-code-frame/-/babel-code-frame-6.26.0.tgz" + integrity sha1-Y/1D99weO7fONZR9uP42mj9Yx0s= + dependencies: + chalk "^1.1.3" + esutils "^2.0.2" + js-tokens "^3.0.2" + +babel-core@^6.0.14, babel-core@^6.26.0: + version "6.26.3" + resolved "https://registry.npmjs.org/babel-core/-/babel-core-6.26.3.tgz" + integrity sha512-6jyFLuDmeidKmUEb3NM+/yawG0M2bDZ9Z1qbZP59cyHLz8kYGKYwpJP0UwUKKUiTRNvxfLesJnTedqczP7cTDA== + dependencies: + babel-code-frame "^6.26.0" + babel-generator "^6.26.0" + babel-helpers "^6.24.1" + babel-messages "^6.23.0" + babel-register "^6.26.0" + babel-runtime "^6.26.0" + babel-template "^6.26.0" + babel-traverse "^6.26.0" + babel-types "^6.26.0" + babylon "^6.18.0" + convert-source-map "^1.5.1" + debug "^2.6.9" + json5 "^0.5.1" + lodash "^4.17.4" + minimatch "^3.0.4" + path-is-absolute "^1.0.1" + private "^0.1.8" + slash "^1.0.0" + source-map "^0.5.7" + +babel-generator@^6.26.0: + version "6.26.1" + resolved "https://registry.npmjs.org/babel-generator/-/babel-generator-6.26.1.tgz" + integrity sha512-HyfwY6ApZj7BYTcJURpM5tznulaBvyio7/0d4zFOeMPUmfxkCjHocCuoLa2SAGzBI8AREcH3eP3758F672DppA== + dependencies: + babel-messages "^6.23.0" + babel-runtime "^6.26.0" + babel-types "^6.26.0" + detect-indent "^4.0.0" + jsesc "^1.3.0" + lodash "^4.17.4" + source-map "^0.5.7" + trim-right "^1.0.1" + +babel-helper-builder-binary-assignment-operator-visitor@^6.24.1: + version "6.24.1" + resolved "https://registry.npmjs.org/babel-helper-builder-binary-assignment-operator-visitor/-/babel-helper-builder-binary-assignment-operator-visitor-6.24.1.tgz" + integrity sha1-zORReto1b0IgvK6KAsKzRvmlZmQ= + dependencies: + babel-helper-explode-assignable-expression "^6.24.1" + babel-runtime "^6.22.0" + babel-types "^6.24.1" + +babel-helper-call-delegate@^6.24.1: + version "6.24.1" + resolved "https://registry.npmjs.org/babel-helper-call-delegate/-/babel-helper-call-delegate-6.24.1.tgz" + integrity sha1-7Oaqzdx25Bw0YfiL/Fdb0Nqi340= + dependencies: + babel-helper-hoist-variables "^6.24.1" + babel-runtime "^6.22.0" + babel-traverse "^6.24.1" + babel-types "^6.24.1" + +babel-helper-define-map@^6.24.1: + version "6.26.0" + resolved "https://registry.npmjs.org/babel-helper-define-map/-/babel-helper-define-map-6.26.0.tgz" + integrity sha1-pfVtq0GiX5fstJjH66ypgZ+Vvl8= + dependencies: + babel-helper-function-name "^6.24.1" + babel-runtime "^6.26.0" + babel-types "^6.26.0" + lodash "^4.17.4" + +babel-helper-explode-assignable-expression@^6.24.1: + version "6.24.1" + resolved "https://registry.npmjs.org/babel-helper-explode-assignable-expression/-/babel-helper-explode-assignable-expression-6.24.1.tgz" + integrity sha1-8luCz33BBDPFX3BZLVdGQArCLKo= + dependencies: + babel-runtime "^6.22.0" + babel-traverse "^6.24.1" + babel-types "^6.24.1" + +babel-helper-function-name@^6.24.1: + version "6.24.1" + resolved "https://registry.npmjs.org/babel-helper-function-name/-/babel-helper-function-name-6.24.1.tgz" + integrity sha1-00dbjAPtmCQqJbSDUasYOZ01gKk= + dependencies: + babel-helper-get-function-arity "^6.24.1" + babel-runtime "^6.22.0" + babel-template "^6.24.1" + babel-traverse "^6.24.1" + babel-types "^6.24.1" + +babel-helper-get-function-arity@^6.24.1: + version "6.24.1" + resolved "https://registry.npmjs.org/babel-helper-get-function-arity/-/babel-helper-get-function-arity-6.24.1.tgz" + integrity sha1-j3eCqpNAfEHTqlCQj4mwMbG2hT0= + dependencies: + babel-runtime "^6.22.0" + babel-types "^6.24.1" + +babel-helper-hoist-variables@^6.24.1: + version "6.24.1" + resolved "https://registry.npmjs.org/babel-helper-hoist-variables/-/babel-helper-hoist-variables-6.24.1.tgz" + integrity sha1-HssnaJydJVE+rbyZFKc/VAi+enY= + dependencies: + babel-runtime "^6.22.0" + babel-types "^6.24.1" + +babel-helper-optimise-call-expression@^6.24.1: + version "6.24.1" + resolved "https://registry.npmjs.org/babel-helper-optimise-call-expression/-/babel-helper-optimise-call-expression-6.24.1.tgz" + integrity sha1-96E0J7qfc/j0+pk8VKl4gtEkQlc= + dependencies: + babel-runtime "^6.22.0" + babel-types "^6.24.1" + +babel-helper-regex@^6.24.1: + version "6.26.0" + resolved "https://registry.npmjs.org/babel-helper-regex/-/babel-helper-regex-6.26.0.tgz" + integrity sha1-MlxZ+QL4LyS3T6zu0DY5VPZJXnI= + dependencies: + babel-runtime "^6.26.0" + babel-types "^6.26.0" + lodash "^4.17.4" + +babel-helper-remap-async-to-generator@^6.24.1: + version "6.24.1" + resolved "https://registry.npmjs.org/babel-helper-remap-async-to-generator/-/babel-helper-remap-async-to-generator-6.24.1.tgz" + integrity sha1-XsWBgnrXI/7N04HxySg5BnbkVRs= + dependencies: + babel-helper-function-name "^6.24.1" + babel-runtime "^6.22.0" + babel-template "^6.24.1" + babel-traverse "^6.24.1" + babel-types "^6.24.1" + +babel-helper-replace-supers@^6.24.1: + version "6.24.1" + resolved "https://registry.npmjs.org/babel-helper-replace-supers/-/babel-helper-replace-supers-6.24.1.tgz" + integrity sha1-v22/5Dk40XNpohPKiov3S2qQqxo= + dependencies: + babel-helper-optimise-call-expression "^6.24.1" + babel-messages "^6.23.0" + babel-runtime "^6.22.0" + babel-template "^6.24.1" + babel-traverse "^6.24.1" + babel-types "^6.24.1" + +babel-helpers@^6.24.1: + version "6.24.1" + resolved "https://registry.npmjs.org/babel-helpers/-/babel-helpers-6.24.1.tgz" + integrity sha1-NHHenK7DiOXIUOWX5Yom3fN2ArI= + dependencies: + babel-runtime "^6.22.0" + babel-template "^6.24.1" + +babel-messages@^6.23.0: + version "6.23.0" + resolved "https://registry.npmjs.org/babel-messages/-/babel-messages-6.23.0.tgz" + integrity sha1-8830cDhYA1sqKVHG7F7fbGLyYw4= + dependencies: + babel-runtime "^6.22.0" + +babel-plugin-check-es2015-constants@^6.22.0: + version "6.22.0" + resolved "https://registry.npmjs.org/babel-plugin-check-es2015-constants/-/babel-plugin-check-es2015-constants-6.22.0.tgz" + integrity sha1-NRV7EBQm/S/9PaP3XH0ekYNbv4o= + dependencies: + babel-runtime "^6.22.0" + +babel-plugin-syntax-async-functions@^6.8.0: + version "6.13.0" + resolved "https://registry.npmjs.org/babel-plugin-syntax-async-functions/-/babel-plugin-syntax-async-functions-6.13.0.tgz" + integrity sha1-ytnK0RkbWtY0vzCuCHI5HgZHvpU= + +babel-plugin-syntax-exponentiation-operator@^6.8.0: + version "6.13.0" + resolved "https://registry.npmjs.org/babel-plugin-syntax-exponentiation-operator/-/babel-plugin-syntax-exponentiation-operator-6.13.0.tgz" + integrity sha1-nufoM3KQ2pUoggGmpX9BcDF4MN4= + +babel-plugin-syntax-trailing-function-commas@^6.22.0: + version "6.22.0" + resolved "https://registry.npmjs.org/babel-plugin-syntax-trailing-function-commas/-/babel-plugin-syntax-trailing-function-commas-6.22.0.tgz" + integrity sha1-ugNgk3+NBuQBgKQ/4NVhb/9TLPM= + +babel-plugin-transform-async-to-generator@^6.22.0: + version "6.24.1" + resolved "https://registry.npmjs.org/babel-plugin-transform-async-to-generator/-/babel-plugin-transform-async-to-generator-6.24.1.tgz" + integrity sha1-ZTbjeK/2yx1VF6wOQOs+n8jQh2E= + dependencies: + babel-helper-remap-async-to-generator "^6.24.1" + babel-plugin-syntax-async-functions "^6.8.0" + babel-runtime "^6.22.0" + +babel-plugin-transform-es2015-arrow-functions@^6.22.0: + version "6.22.0" + resolved "https://registry.npmjs.org/babel-plugin-transform-es2015-arrow-functions/-/babel-plugin-transform-es2015-arrow-functions-6.22.0.tgz" + integrity sha1-RSaSy3EdX3ncf4XkQM5BufJE0iE= + dependencies: + babel-runtime "^6.22.0" + +babel-plugin-transform-es2015-block-scoped-functions@^6.22.0: + version "6.22.0" + resolved "https://registry.npmjs.org/babel-plugin-transform-es2015-block-scoped-functions/-/babel-plugin-transform-es2015-block-scoped-functions-6.22.0.tgz" + integrity sha1-u8UbSflk1wy42OC5ToICRs46YUE= + dependencies: + babel-runtime "^6.22.0" + +babel-plugin-transform-es2015-block-scoping@^6.23.0: + version "6.26.0" + resolved "https://registry.npmjs.org/babel-plugin-transform-es2015-block-scoping/-/babel-plugin-transform-es2015-block-scoping-6.26.0.tgz" + integrity sha1-1w9SmcEwjQXBL0Y4E7CgnnOxiV8= + dependencies: + babel-runtime "^6.26.0" + babel-template "^6.26.0" + babel-traverse "^6.26.0" + babel-types "^6.26.0" + lodash "^4.17.4" + +babel-plugin-transform-es2015-classes@^6.23.0: + version "6.24.1" + resolved "https://registry.npmjs.org/babel-plugin-transform-es2015-classes/-/babel-plugin-transform-es2015-classes-6.24.1.tgz" + integrity sha1-WkxYpQyclGHlZLSyo7+ryXolhNs= + dependencies: + babel-helper-define-map "^6.24.1" + babel-helper-function-name "^6.24.1" + babel-helper-optimise-call-expression "^6.24.1" + babel-helper-replace-supers "^6.24.1" + babel-messages "^6.23.0" + babel-runtime "^6.22.0" + babel-template "^6.24.1" + babel-traverse "^6.24.1" + babel-types "^6.24.1" + +babel-plugin-transform-es2015-computed-properties@^6.22.0: + version "6.24.1" + resolved "https://registry.npmjs.org/babel-plugin-transform-es2015-computed-properties/-/babel-plugin-transform-es2015-computed-properties-6.24.1.tgz" + integrity sha1-b+Ko0WiV1WNPTNmZttNICjCBWbM= + dependencies: + babel-runtime "^6.22.0" + babel-template "^6.24.1" + +babel-plugin-transform-es2015-destructuring@^6.23.0: + version "6.23.0" + resolved "https://registry.npmjs.org/babel-plugin-transform-es2015-destructuring/-/babel-plugin-transform-es2015-destructuring-6.23.0.tgz" + integrity sha1-mXux8auWf2gtKwh2/jWNYOdlxW0= + dependencies: + babel-runtime "^6.22.0" + +babel-plugin-transform-es2015-duplicate-keys@^6.22.0: + version "6.24.1" + resolved "https://registry.npmjs.org/babel-plugin-transform-es2015-duplicate-keys/-/babel-plugin-transform-es2015-duplicate-keys-6.24.1.tgz" + integrity sha1-c+s9MQypaePvnskcU3QabxV2Qj4= + dependencies: + babel-runtime "^6.22.0" + babel-types "^6.24.1" + +babel-plugin-transform-es2015-for-of@^6.23.0: + version "6.23.0" + resolved "https://registry.npmjs.org/babel-plugin-transform-es2015-for-of/-/babel-plugin-transform-es2015-for-of-6.23.0.tgz" + integrity sha1-9HyVsrYT3x0+zC/bdXNiPHUkhpE= + dependencies: + babel-runtime "^6.22.0" + +babel-plugin-transform-es2015-function-name@^6.22.0: + version "6.24.1" + resolved "https://registry.npmjs.org/babel-plugin-transform-es2015-function-name/-/babel-plugin-transform-es2015-function-name-6.24.1.tgz" + integrity sha1-g0yJhTvDaxrw86TF26qU/Y6sqos= + dependencies: + babel-helper-function-name "^6.24.1" + babel-runtime "^6.22.0" + babel-types "^6.24.1" + +babel-plugin-transform-es2015-literals@^6.22.0: + version "6.22.0" + resolved "https://registry.npmjs.org/babel-plugin-transform-es2015-literals/-/babel-plugin-transform-es2015-literals-6.22.0.tgz" + integrity sha1-T1SgLWzWbPkVKAAZox0xklN3yi4= + dependencies: + babel-runtime "^6.22.0" + +babel-plugin-transform-es2015-modules-amd@^6.22.0, babel-plugin-transform-es2015-modules-amd@^6.24.1: + version "6.24.1" + resolved "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-amd/-/babel-plugin-transform-es2015-modules-amd-6.24.1.tgz" + integrity sha1-Oz5UAXI5hC1tGcMBHEvS8AoA0VQ= + dependencies: + babel-plugin-transform-es2015-modules-commonjs "^6.24.1" + babel-runtime "^6.22.0" + babel-template "^6.24.1" + +babel-plugin-transform-es2015-modules-commonjs@^6.23.0, babel-plugin-transform-es2015-modules-commonjs@^6.24.1: + version "6.26.2" + resolved "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-commonjs/-/babel-plugin-transform-es2015-modules-commonjs-6.26.2.tgz" + integrity sha512-CV9ROOHEdrjcwhIaJNBGMBCodN+1cfkwtM1SbUHmvyy35KGT7fohbpOxkE2uLz1o6odKK2Ck/tz47z+VqQfi9Q== + dependencies: + babel-plugin-transform-strict-mode "^6.24.1" + babel-runtime "^6.26.0" + babel-template "^6.26.0" + babel-types "^6.26.0" + +babel-plugin-transform-es2015-modules-systemjs@^6.23.0: + version "6.24.1" + resolved "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-systemjs/-/babel-plugin-transform-es2015-modules-systemjs-6.24.1.tgz" + integrity sha1-/4mhQrkRmpBhlfXxBuzzBdlAfSM= + dependencies: + babel-helper-hoist-variables "^6.24.1" + babel-runtime "^6.22.0" + babel-template "^6.24.1" + +babel-plugin-transform-es2015-modules-umd@^6.23.0: + version "6.24.1" + resolved "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-umd/-/babel-plugin-transform-es2015-modules-umd-6.24.1.tgz" + integrity sha1-rJl+YoXNGO1hdq22B9YCNErThGg= + dependencies: + babel-plugin-transform-es2015-modules-amd "^6.24.1" + babel-runtime "^6.22.0" + babel-template "^6.24.1" + +babel-plugin-transform-es2015-object-super@^6.22.0: + version "6.24.1" + resolved "https://registry.npmjs.org/babel-plugin-transform-es2015-object-super/-/babel-plugin-transform-es2015-object-super-6.24.1.tgz" + integrity sha1-JM72muIcuDp/hgPa0CH1cusnj40= + dependencies: + babel-helper-replace-supers "^6.24.1" + babel-runtime "^6.22.0" + +babel-plugin-transform-es2015-parameters@^6.23.0: + version "6.24.1" + resolved "https://registry.npmjs.org/babel-plugin-transform-es2015-parameters/-/babel-plugin-transform-es2015-parameters-6.24.1.tgz" + integrity sha1-V6w1GrScrxSpfNE7CfZv3wpiXys= + dependencies: + babel-helper-call-delegate "^6.24.1" + babel-helper-get-function-arity "^6.24.1" + babel-runtime "^6.22.0" + babel-template "^6.24.1" + babel-traverse "^6.24.1" + babel-types "^6.24.1" + +babel-plugin-transform-es2015-shorthand-properties@^6.22.0: + version "6.24.1" + resolved "https://registry.npmjs.org/babel-plugin-transform-es2015-shorthand-properties/-/babel-plugin-transform-es2015-shorthand-properties-6.24.1.tgz" + integrity sha1-JPh11nIch2YbvZmkYi5R8U3jiqA= + dependencies: + babel-runtime "^6.22.0" + babel-types "^6.24.1" + +babel-plugin-transform-es2015-spread@^6.22.0: + version "6.22.0" + resolved "https://registry.npmjs.org/babel-plugin-transform-es2015-spread/-/babel-plugin-transform-es2015-spread-6.22.0.tgz" + integrity sha1-1taKmfia7cRTbIGlQujdnxdG+NE= + dependencies: + babel-runtime "^6.22.0" + +babel-plugin-transform-es2015-sticky-regex@^6.22.0: + version "6.24.1" + resolved "https://registry.npmjs.org/babel-plugin-transform-es2015-sticky-regex/-/babel-plugin-transform-es2015-sticky-regex-6.24.1.tgz" + integrity sha1-AMHNsaynERLN8M9hJsLta0V8zbw= + dependencies: + babel-helper-regex "^6.24.1" + babel-runtime "^6.22.0" + babel-types "^6.24.1" + +babel-plugin-transform-es2015-template-literals@^6.22.0: + version "6.22.0" + resolved "https://registry.npmjs.org/babel-plugin-transform-es2015-template-literals/-/babel-plugin-transform-es2015-template-literals-6.22.0.tgz" + integrity sha1-qEs0UPfp+PH2g51taH2oS7EjbY0= + dependencies: + babel-runtime "^6.22.0" + +babel-plugin-transform-es2015-typeof-symbol@^6.23.0: + version "6.23.0" + resolved "https://registry.npmjs.org/babel-plugin-transform-es2015-typeof-symbol/-/babel-plugin-transform-es2015-typeof-symbol-6.23.0.tgz" + integrity sha1-3sCfHN3/lLUqxz1QXITfWdzOs3I= + dependencies: + babel-runtime "^6.22.0" + +babel-plugin-transform-es2015-unicode-regex@^6.22.0: + version "6.24.1" + resolved "https://registry.npmjs.org/babel-plugin-transform-es2015-unicode-regex/-/babel-plugin-transform-es2015-unicode-regex-6.24.1.tgz" + integrity sha1-04sS9C6nMj9yk4fxinxa4frrNek= + dependencies: + babel-helper-regex "^6.24.1" + babel-runtime "^6.22.0" + regexpu-core "^2.0.0" + +babel-plugin-transform-exponentiation-operator@^6.22.0: + version "6.24.1" + resolved "https://registry.npmjs.org/babel-plugin-transform-exponentiation-operator/-/babel-plugin-transform-exponentiation-operator-6.24.1.tgz" + integrity sha1-KrDJx/MJj6SJB3cruBP+QejeOg4= + dependencies: + babel-helper-builder-binary-assignment-operator-visitor "^6.24.1" + babel-plugin-syntax-exponentiation-operator "^6.8.0" + babel-runtime "^6.22.0" + +babel-plugin-transform-regenerator@^6.22.0: + version "6.26.0" + resolved "https://registry.npmjs.org/babel-plugin-transform-regenerator/-/babel-plugin-transform-regenerator-6.26.0.tgz" + integrity sha1-4HA2lvveJ/Cj78rPi03KL3s6jy8= + dependencies: + regenerator-transform "^0.10.0" + +babel-plugin-transform-strict-mode@^6.24.1: + version "6.24.1" + resolved "https://registry.npmjs.org/babel-plugin-transform-strict-mode/-/babel-plugin-transform-strict-mode-6.24.1.tgz" + integrity sha1-1fr3qleKZbvlkc9e2uBKDGcCB1g= + dependencies: + babel-runtime "^6.22.0" + babel-types "^6.24.1" + +babel-preset-env@^1.7.0: + version "1.7.0" + resolved "https://registry.npmjs.org/babel-preset-env/-/babel-preset-env-1.7.0.tgz" + integrity sha512-9OR2afuKDneX2/q2EurSftUYM0xGu4O2D9adAhVfADDhrYDaxXV0rBbevVYoY9n6nyX1PmQW/0jtpJvUNr9CHg== + dependencies: + babel-plugin-check-es2015-constants "^6.22.0" + babel-plugin-syntax-trailing-function-commas "^6.22.0" + babel-plugin-transform-async-to-generator "^6.22.0" + babel-plugin-transform-es2015-arrow-functions "^6.22.0" + babel-plugin-transform-es2015-block-scoped-functions "^6.22.0" + babel-plugin-transform-es2015-block-scoping "^6.23.0" + babel-plugin-transform-es2015-classes "^6.23.0" + babel-plugin-transform-es2015-computed-properties "^6.22.0" + babel-plugin-transform-es2015-destructuring "^6.23.0" + babel-plugin-transform-es2015-duplicate-keys "^6.22.0" + babel-plugin-transform-es2015-for-of "^6.23.0" + babel-plugin-transform-es2015-function-name "^6.22.0" + babel-plugin-transform-es2015-literals "^6.22.0" + babel-plugin-transform-es2015-modules-amd "^6.22.0" + babel-plugin-transform-es2015-modules-commonjs "^6.23.0" + babel-plugin-transform-es2015-modules-systemjs "^6.23.0" + babel-plugin-transform-es2015-modules-umd "^6.23.0" + babel-plugin-transform-es2015-object-super "^6.22.0" + babel-plugin-transform-es2015-parameters "^6.23.0" + babel-plugin-transform-es2015-shorthand-properties "^6.22.0" + babel-plugin-transform-es2015-spread "^6.22.0" + babel-plugin-transform-es2015-sticky-regex "^6.22.0" + babel-plugin-transform-es2015-template-literals "^6.22.0" + babel-plugin-transform-es2015-typeof-symbol "^6.23.0" + babel-plugin-transform-es2015-unicode-regex "^6.22.0" + babel-plugin-transform-exponentiation-operator "^6.22.0" + babel-plugin-transform-regenerator "^6.22.0" + browserslist "^3.2.6" + invariant "^2.2.2" + semver "^5.3.0" + +babel-register@^6.26.0: + version "6.26.0" + resolved "https://registry.npmjs.org/babel-register/-/babel-register-6.26.0.tgz" + integrity sha1-btAhFz4vy0htestFxgCahW9kcHE= + dependencies: + babel-core "^6.26.0" + babel-runtime "^6.26.0" + core-js "^2.5.0" + home-or-tmp "^2.0.0" + lodash "^4.17.4" + mkdirp "^0.5.1" + source-map-support "^0.4.15" + +babel-runtime@^6.18.0, babel-runtime@^6.22.0, babel-runtime@^6.26.0: + version "6.26.0" + resolved "https://registry.npmjs.org/babel-runtime/-/babel-runtime-6.26.0.tgz" + integrity sha1-llxwWGaOgrVde/4E/yM3vItWR/4= + dependencies: + core-js "^2.4.0" + regenerator-runtime "^0.11.0" + +babel-template@^6.24.1, babel-template@^6.26.0: + version "6.26.0" + resolved "https://registry.npmjs.org/babel-template/-/babel-template-6.26.0.tgz" + integrity sha1-3gPi0WOWsGn0bdn/+FIfsaDjXgI= + dependencies: + babel-runtime "^6.26.0" + babel-traverse "^6.26.0" + babel-types "^6.26.0" + babylon "^6.18.0" + lodash "^4.17.4" + +babel-traverse@^6.24.1, babel-traverse@^6.26.0: + version "6.26.0" + resolved "https://registry.npmjs.org/babel-traverse/-/babel-traverse-6.26.0.tgz" + integrity sha1-RqnL1+3MYsjlwGTi0tjQ9ANXZu4= + dependencies: + babel-code-frame "^6.26.0" + babel-messages "^6.23.0" + babel-runtime "^6.26.0" + babel-types "^6.26.0" + babylon "^6.18.0" + debug "^2.6.8" + globals "^9.18.0" + invariant "^2.2.2" + lodash "^4.17.4" + +babel-types@^6.19.0, babel-types@^6.24.1, babel-types@^6.26.0: + version "6.26.0" + resolved "https://registry.npmjs.org/babel-types/-/babel-types-6.26.0.tgz" + integrity sha1-o7Bz+Uq0nrb6Vc1lInozQ4BjJJc= + dependencies: + babel-runtime "^6.26.0" + esutils "^2.0.2" + lodash "^4.17.4" + to-fast-properties "^1.0.3" + +babelify@^7.3.0: + version "7.3.0" + resolved "https://registry.npmjs.org/babelify/-/babelify-7.3.0.tgz" + integrity sha1-qlau3nBn/XvVSWZu4W3ChQh+iOU= + dependencies: + babel-core "^6.0.14" + object-assign "^4.0.0" + +babylon@^6.18.0: + version "6.18.0" + resolved "https://registry.npmjs.org/babylon/-/babylon-6.18.0.tgz" + integrity sha512-q/UEjfGJ2Cm3oKV71DJz9d25TPnq5rhBVL2Q4fA5wcC3jcrdn7+SssEybFIxwAvvP+YCsCYNKughoF33GxgycQ== + +backoff@^2.5.0: + version "2.5.0" + resolved "https://registry.npmjs.org/backoff/-/backoff-2.5.0.tgz" + integrity sha1-9hbtqdPktmuMp/ynn2lXIsX44m8= + dependencies: + precond "0.2" + +balanced-match@^1.0.0: + version "1.0.2" + resolved "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz" + integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw== + +base-x@^3.0.2, base-x@^3.0.8: + version "3.0.9" + resolved "https://registry.npmjs.org/base-x/-/base-x-3.0.9.tgz" + integrity sha512-H7JU6iBHTal1gp56aKoaa//YUxEaAOUiydvrV/pILqIHXTtqxSkATOnDA2u+jZ/61sD+L/412+7kzXRtWukhpQ== + dependencies: + safe-buffer "^5.0.1" + +base64-js@^1.3.1: + version "1.5.1" + resolved "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz" + integrity sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA== + +base@^0.11.1: + version "0.11.2" + resolved "https://registry.npmjs.org/base/-/base-0.11.2.tgz" + integrity sha512-5T6P4xPgpp0YDFvSWwEZ4NoE3aM4QBQXDzmVbraCkFj8zHM+mba8SyqB5DbZWyR7mYHo6Y7BdQo3MoA4m0TeQg== + dependencies: + cache-base "^1.0.1" + class-utils "^0.3.5" + component-emitter "^1.2.1" + define-property "^1.0.0" + isobject "^3.0.1" + mixin-deep "^1.2.0" + pascalcase "^0.1.1" + +bcrypt-pbkdf@^1.0.0: + version "1.0.2" + resolved "https://registry.npmjs.org/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz" + integrity sha1-pDAdOJtqQ/m2f/PKEaP2Y342Dp4= + dependencies: + tweetnacl "^0.14.3" + +bech32@1.1.4: + version "1.1.4" + resolved "https://registry.npmjs.org/bech32/-/bech32-1.1.4.tgz" + integrity sha512-s0IrSOzLlbvX7yp4WBfPITzpAU8sqQcpsmwXDiKwrG4r491vwCO/XpejasRNl0piBMe/DvP4Tz0mIS/X1DPJBQ== + +big.js@^6.1.1: + version "6.2.0" + resolved "https://registry.yarnpkg.com/big.js/-/big.js-6.2.0.tgz#39c60822aecb0f34a1d79a90fe9908a0ddf45e1d" + integrity sha512-paIKvJiAaOYdLt6MfnvxkDo64lTOV257XYJyX3oJnJQocIclUn+48k6ZerH/c5FxWE6DGJu1TKDYis7tqHg9kg== + +bignumber.js@^9.0.0, bignumber.js@^9.0.1: + version "9.0.2" + resolved "https://registry.npmjs.org/bignumber.js/-/bignumber.js-9.0.2.tgz" + integrity sha512-GAcQvbpsM0pUb0zw1EI0KhQEZ+lRwR5fYaAp3vPOYuP7aDvGy6cVN6XHLauvF8SOga2y0dcLcjt3iQDTSEliyw== + +binary-extensions@^2.0.0: + version "2.2.0" + resolved "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz" + integrity sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA== + +bip39@2.5.0: + version "2.5.0" + resolved "https://registry.npmjs.org/bip39/-/bip39-2.5.0.tgz" + integrity sha512-xwIx/8JKoT2+IPJpFEfXoWdYwP7UVAoUxxLNfGCfVowaJE7yg1Y5B1BVPqlUNsBq5/nGwmFkwRJ8xDW4sX8OdA== + dependencies: + create-hash "^1.1.0" + pbkdf2 "^3.0.9" + randombytes "^2.0.1" + safe-buffer "^5.0.1" + unorm "^1.3.3" + +blakejs@^1.1.0: + version "1.2.1" + resolved "https://registry.npmjs.org/blakejs/-/blakejs-1.2.1.tgz" + integrity sha512-QXUSXI3QVc/gJME0dBpXrag1kbzOqCjCX8/b54ntNyW6sjtoqxqRk3LTmXzaJoh71zMsDCjM+47jS7XiwN/+fQ== + +bluebird@^3.5.0, bluebird@^3.5.2: + version "3.7.2" + resolved "https://registry.npmjs.org/bluebird/-/bluebird-3.7.2.tgz" + integrity sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg== + +bn.js@4.11.6: + version "4.11.6" + resolved "https://registry.npmjs.org/bn.js/-/bn.js-4.11.6.tgz" + integrity sha1-UzRK2xRhehP26N0s4okF0cC6MhU= + +bn.js@^4.0.0, bn.js@^4.1.0, bn.js@^4.10.0, bn.js@^4.11.0, bn.js@^4.11.6, bn.js@^4.11.8, bn.js@^4.11.9, bn.js@^4.8.0: + version "4.12.0" + resolved "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz" + integrity sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA== + +bn.js@^5.0.0, bn.js@^5.1.1, bn.js@^5.1.2, bn.js@^5.1.3, bn.js@^5.2.0: + version "5.2.0" + resolved "https://registry.npmjs.org/bn.js/-/bn.js-5.2.0.tgz" + integrity sha512-D7iWRBvnZE8ecXiLj/9wbxH7Tk79fAh8IHaTNq1RWRixsS02W+5qS+iE9yq6RYl0asXx5tw0bLhmT5pIfbSquw== + +bn.js@^5.2.1: + version "5.2.1" + resolved "https://registry.yarnpkg.com/bn.js/-/bn.js-5.2.1.tgz#0bc527a6a0d18d0aa8d5b0538ce4a77dccfa7b70" + integrity sha512-eXRvHzWyYPBuB4NBy0cmYQjGitUrtqwbvlzP3G6VFnNRbsZQIxQ10PbKKHt8gZ/HW/D/747aDl+QkDqg3KQLMQ== + +body-parser@1.20.0, body-parser@^1.16.0: + version "1.20.0" + resolved "https://registry.npmjs.org/body-parser/-/body-parser-1.20.0.tgz" + integrity sha512-DfJ+q6EPcGKZD1QWUjSpqp+Q7bDQTsQIF4zfUAtZ6qk+H/3/QRhg9CEp39ss+/T2vw0+HaidC0ecJj/DRLIaKg== + dependencies: + bytes "3.1.2" + content-type "~1.0.4" + debug "2.6.9" + depd "2.0.0" + destroy "1.2.0" + http-errors "2.0.0" + iconv-lite "0.4.24" + on-finished "2.4.1" + qs "6.10.3" + raw-body "2.5.1" + type-is "~1.6.18" + unpipe "1.0.0" + +brace-expansion@^1.1.7: + version "1.1.11" + resolved "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz" + integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA== + dependencies: + balanced-match "^1.0.0" + concat-map "0.0.1" + +braces@^2.3.1: + version "2.3.2" + resolved "https://registry.npmjs.org/braces/-/braces-2.3.2.tgz" + integrity sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w== + dependencies: + arr-flatten "^1.1.0" + array-unique "^0.3.2" + extend-shallow "^2.0.1" + fill-range "^4.0.0" + isobject "^3.0.1" + repeat-element "^1.1.2" + snapdragon "^0.8.1" + snapdragon-node "^2.0.1" + split-string "^3.0.2" + to-regex "^3.0.1" + +braces@^3.0.2, braces@~3.0.2: + version "3.0.2" + resolved "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz" + integrity sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A== + dependencies: + fill-range "^7.0.1" + +brorand@^1.0.1, brorand@^1.1.0: + version "1.1.0" + resolved "https://registry.npmjs.org/brorand/-/brorand-1.1.0.tgz" + integrity sha1-EsJe/kCkXjwyPrhnWgoM5XsiNx8= + +browser-stdout@1.3.1: + version "1.3.1" + resolved "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.1.tgz" + integrity sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw== + +browserify-aes@^1.0.0, browserify-aes@^1.0.4, browserify-aes@^1.2.0: + version "1.2.0" + resolved "https://registry.npmjs.org/browserify-aes/-/browserify-aes-1.2.0.tgz" + integrity sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA== + dependencies: + buffer-xor "^1.0.3" + cipher-base "^1.0.0" + create-hash "^1.1.0" + evp_bytestokey "^1.0.3" + inherits "^2.0.1" + safe-buffer "^5.0.1" + +browserify-cipher@^1.0.0: + version "1.0.1" + resolved "https://registry.npmjs.org/browserify-cipher/-/browserify-cipher-1.0.1.tgz" + integrity sha512-sPhkz0ARKbf4rRQt2hTpAHqn47X3llLkUGn+xEJzLjwY8LRs2p0v7ljvI5EyoRO/mexrNunNECisZs+gw2zz1w== + dependencies: + browserify-aes "^1.0.4" + browserify-des "^1.0.0" + evp_bytestokey "^1.0.0" + +browserify-des@^1.0.0: + version "1.0.2" + resolved "https://registry.npmjs.org/browserify-des/-/browserify-des-1.0.2.tgz" + integrity sha512-BioO1xf3hFwz4kc6iBhI3ieDFompMhrMlnDFC4/0/vd5MokpuAc3R+LYbwTA9A5Yc9pq9UYPqffKpW2ObuwX5A== + dependencies: + cipher-base "^1.0.1" + des.js "^1.0.0" + inherits "^2.0.1" + safe-buffer "^5.1.2" + +browserify-rsa@^4.0.0, browserify-rsa@^4.0.1: + version "4.1.0" + resolved "https://registry.npmjs.org/browserify-rsa/-/browserify-rsa-4.1.0.tgz" + integrity sha512-AdEER0Hkspgno2aR97SAf6vi0y0k8NuOpGnVH3O99rcA5Q6sh8QxcngtHuJ6uXwnfAXNM4Gn1Gb7/MV1+Ymbog== + dependencies: + bn.js "^5.0.0" + randombytes "^2.0.1" + +browserify-sign@^4.0.0: + version "4.2.1" + resolved "https://registry.npmjs.org/browserify-sign/-/browserify-sign-4.2.1.tgz" + integrity sha512-/vrA5fguVAKKAVTNJjgSm1tRQDHUU6DbwO9IROu/0WAzC8PKhucDSh18J0RMvVeHAn5puMd+QHC2erPRNf8lmg== + dependencies: + bn.js "^5.1.1" + browserify-rsa "^4.0.1" + create-hash "^1.2.0" + create-hmac "^1.1.7" + elliptic "^6.5.3" + inherits "^2.0.4" + parse-asn1 "^5.1.5" + readable-stream "^3.6.0" + safe-buffer "^5.2.0" + +browserslist@^3.2.6: + version "3.2.8" + resolved "https://registry.npmjs.org/browserslist/-/browserslist-3.2.8.tgz" + integrity sha512-WHVocJYavUwVgVViC0ORikPHQquXwVh939TaelZ4WDqpWgTX/FsGhl/+P4qBUAGcRvtOgDgC+xftNWWp2RUTAQ== + dependencies: + caniuse-lite "^1.0.30000844" + electron-to-chromium "^1.3.47" + +bs58@^4.0.0: + version "4.0.1" + resolved "https://registry.npmjs.org/bs58/-/bs58-4.0.1.tgz" + integrity sha1-vhYedsNU9veIrkBx9j806MTwpCo= + dependencies: + base-x "^3.0.2" + +bs58check@^2.1.2: + version "2.1.2" + resolved "https://registry.npmjs.org/bs58check/-/bs58check-2.1.2.tgz" + integrity sha512-0TS1jicxdU09dwJMNZtVAfzPi6Q6QeN0pM1Fkzrjn+XYHvzMKPU3pHVpva+769iNVSfIYWf7LJ6WR+BuuMf8cA== + dependencies: + bs58 "^4.0.0" + create-hash "^1.1.0" + safe-buffer "^5.1.2" + +buffer-from@^1.0.0: + version "1.1.2" + resolved "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz" + integrity sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ== + +buffer-to-arraybuffer@^0.0.5: + version "0.0.5" + resolved "https://registry.npmjs.org/buffer-to-arraybuffer/-/buffer-to-arraybuffer-0.0.5.tgz" + integrity sha1-YGSkD6dutDxyOrqe+PbhIW0QURo= + +buffer-xor@^1.0.3: + version "1.0.3" + resolved "https://registry.npmjs.org/buffer-xor/-/buffer-xor-1.0.3.tgz" + integrity sha1-JuYe0UIvtw3ULm42cp7VHYVf6Nk= + +buffer-xor@^2.0.1: + version "2.0.2" + resolved "https://registry.npmjs.org/buffer-xor/-/buffer-xor-2.0.2.tgz" + integrity sha512-eHslX0bin3GB+Lx2p7lEYRShRewuNZL3fUl4qlVJGGiwoPGftmt8JQgk2Y9Ji5/01TnVDo33E5b5O3vUB1HdqQ== + dependencies: + safe-buffer "^5.1.1" + +buffer@^5.0.5, buffer@^5.2.1, buffer@^5.5.0, buffer@^5.6.0: + version "5.7.1" + resolved "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz" + integrity sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ== + dependencies: + base64-js "^1.3.1" + ieee754 "^1.1.13" + +bufferutil@^4.0.1: + version "4.0.6" + resolved "https://registry.npmjs.org/bufferutil/-/bufferutil-4.0.6.tgz" + integrity sha512-jduaYOYtnio4aIAyc6UbvPCVcgq7nYpVnucyxr6eCYg/Woad9Hf/oxxBRDnGGjPfjUm6j5O/uBWhIu4iLebFaw== + dependencies: + node-gyp-build "^4.3.0" + +builtins@^5.0.1: + version "5.0.1" + resolved "https://registry.yarnpkg.com/builtins/-/builtins-5.0.1.tgz#87f6db9ab0458be728564fa81d876d8d74552fa9" + integrity sha512-qwVpFEHNfhYJIzNRBvd2C1kyo6jz3ZSMPyyuR47OPdiKWlbYnZNyDWuyR175qDnAJLiCo5fBBqPb3RiXgWlkOQ== + dependencies: + semver "^7.0.0" + +bytes@3.1.2: + version "3.1.2" + resolved "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz" + integrity sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg== + +bytewise-core@^1.2.2: + version "1.2.3" + resolved "https://registry.npmjs.org/bytewise-core/-/bytewise-core-1.2.3.tgz" + integrity sha1-P7QQx+kVWOsasiqCg0V3qmvWHUI= + dependencies: + typewise-core "^1.2" + +bytewise@~1.1.0: + version "1.1.0" + resolved "https://registry.npmjs.org/bytewise/-/bytewise-1.1.0.tgz" + integrity sha1-HRPL/3F65xWAlKqIGzXQgbOHJT4= + dependencies: + bytewise-core "^1.2.2" + typewise "^1.0.3" + +cache-base@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/cache-base/-/cache-base-1.0.1.tgz" + integrity sha512-AKcdTnFSWATd5/GCPRxr2ChwIJ85CeyrEyjRHlKxQ56d4XJMGym0uAiKn0xbLOGOl3+yRpOTi484dVCEc5AUzQ== + dependencies: + collection-visit "^1.0.0" + component-emitter "^1.2.1" + get-value "^2.0.6" + has-value "^1.0.0" + isobject "^3.0.1" + set-value "^2.0.0" + to-object-path "^0.3.0" + union-value "^1.0.0" + unset-value "^1.0.0" + +cacheable-request@^6.0.0: + version "6.1.0" + resolved "https://registry.npmjs.org/cacheable-request/-/cacheable-request-6.1.0.tgz" + integrity sha512-Oj3cAGPCqOZX7Rz64Uny2GYAZNliQSqfbePrgAQ1wKAihYmCUnraBtJtKcGR4xz7wF+LoJC+ssFZvv5BgF9Igg== + dependencies: + clone-response "^1.0.2" + get-stream "^5.1.0" + http-cache-semantics "^4.0.0" + keyv "^3.0.0" + lowercase-keys "^2.0.0" + normalize-url "^4.1.0" + responselike "^1.0.2" + +cachedown@1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/cachedown/-/cachedown-1.0.0.tgz" + integrity sha1-1D8DbkUQaWsxJG19sx6/D3rDLRU= + dependencies: + abstract-leveldown "^2.4.1" + lru-cache "^3.2.0" + +call-bind@^1.0.0, call-bind@^1.0.2, call-bind@~1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz" + integrity sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA== + dependencies: + function-bind "^1.1.1" + get-intrinsic "^1.0.2" + +caller-callsite@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/caller-callsite/-/caller-callsite-2.0.0.tgz" + integrity sha1-hH4PzgoiN1CpoCfFSzNzGtMVQTQ= + dependencies: + callsites "^2.0.0" + +caller-path@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/caller-path/-/caller-path-2.0.0.tgz" + integrity sha1-Ro+DBE42mrIBD6xfBs7uFbsssfQ= + dependencies: + caller-callsite "^2.0.0" + +callsites@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/callsites/-/callsites-2.0.0.tgz" + integrity sha1-BuuE8A7qQT2oav/vrL/7Ngk7PFA= + +callsites@^3.0.0: + version "3.1.0" + resolved "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz" + integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ== + +camelcase@^6.0.0: + version "6.3.0" + resolved "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz" + integrity sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA== + +caniuse-lite@^1.0.30000844: + version "1.0.30001338" + resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001338.tgz#b5dd7a7941a51a16480bdf6ff82bded1628eec0d" + integrity sha512-1gLHWyfVoRDsHieO+CaeYe7jSo/MT7D7lhaXUiwwbuR5BwQxORs0f1tAwUSQr3YbxRXJvxHM/PA5FfPQRnsPeQ== + +caseless@^0.12.0, caseless@~0.12.0: + version "0.12.0" + resolved "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz" + integrity sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw= + +cbor@^5.0.2: + version "5.2.0" + resolved "https://registry.yarnpkg.com/cbor/-/cbor-5.2.0.tgz#4cca67783ccd6de7b50ab4ed62636712f287a67c" + integrity sha512-5IMhi9e1QU76ppa5/ajP1BmMWZ2FHkhAhjeVKQ/EFCgYSEaeVaoGtL7cxJskf9oCCk+XjzaIdc3IuU/dbA/o2A== + dependencies: + bignumber.js "^9.0.1" + nofilter "^1.0.4" + +cbor@^8.0.0: + version "8.1.0" + resolved "https://registry.yarnpkg.com/cbor/-/cbor-8.1.0.tgz#cfc56437e770b73417a2ecbfc9caf6b771af60d5" + integrity sha512-DwGjNW9omn6EwP70aXsn7FQJx5kO12tX0bZkaTjzdVFM6/7nhA4t0EENocKGx6D2Bch9PE2KzCUf5SceBdeijg== + dependencies: + nofilter "^3.1.0" + +chai@^4.3.6: + version "4.3.6" + resolved "https://registry.yarnpkg.com/chai/-/chai-4.3.6.tgz#ffe4ba2d9fa9d6680cc0b370adae709ec9011e9c" + integrity sha512-bbcp3YfHCUzMOvKqsztczerVgBKSsEijCySNlHHbX3VG1nskvqjz5Rfso1gGwD6w6oOV3eI60pKuMOV5MV7p3Q== + dependencies: + assertion-error "^1.1.0" + check-error "^1.0.2" + deep-eql "^3.0.1" + get-func-name "^2.0.0" + loupe "^2.3.1" + pathval "^1.1.1" + type-detect "^4.0.5" + +chalk@^1.1.3: + version "1.1.3" + resolved "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz" + integrity sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg= + dependencies: + ansi-styles "^2.2.1" + escape-string-regexp "^1.0.2" + has-ansi "^2.0.0" + strip-ansi "^3.0.0" + supports-color "^2.0.0" + +chalk@^2.0.0, chalk@^2.1.0, chalk@^2.4.1, chalk@^2.4.2: + version "2.4.2" + resolved "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz" + integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ== + dependencies: + ansi-styles "^3.2.1" + escape-string-regexp "^1.0.5" + supports-color "^5.3.0" + +chalk@^4.0.0, chalk@^4.1.0, chalk@^4.1.2: + version "4.1.2" + resolved "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz" + integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA== + dependencies: + ansi-styles "^4.1.0" + supports-color "^7.1.0" + +chardet@^0.7.0: + version "0.7.0" + resolved "https://registry.npmjs.org/chardet/-/chardet-0.7.0.tgz" + integrity sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA== + +"charenc@>= 0.0.1": + version "0.0.2" + resolved "https://registry.npmjs.org/charenc/-/charenc-0.0.2.tgz" + integrity sha1-wKHS86cJLgN3S/qD8UwPxXkKhmc= + +check-error@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/check-error/-/check-error-1.0.2.tgz" + integrity sha1-V00xLt2Iu13YkS6Sht1sCu1KrII= + +checkpoint-store@^1.1.0: + version "1.1.0" + resolved "https://registry.npmjs.org/checkpoint-store/-/checkpoint-store-1.1.0.tgz" + integrity sha1-BOTLUWuRQziTWB5tRgGnjpVS6gY= + dependencies: + functional-red-black-tree "^1.0.1" + +chokidar@3.3.0: + version "3.3.0" + resolved "https://registry.npmjs.org/chokidar/-/chokidar-3.3.0.tgz" + integrity sha512-dGmKLDdT3Gdl7fBUe8XK+gAtGmzy5Fn0XkkWQuYxGIgWVPPse2CxFA5mtrlD0TOHaHjEUqkWNyP1XdHoJES/4A== + dependencies: + anymatch "~3.1.1" + braces "~3.0.2" + glob-parent "~5.1.0" + is-binary-path "~2.1.0" + is-glob "~4.0.1" + normalize-path "~3.0.0" + readdirp "~3.2.0" + optionalDependencies: + fsevents "~2.1.1" + +chokidar@3.5.3, chokidar@^3.4.0, chokidar@^3.5.2: + version "3.5.3" + resolved "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz" + integrity sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw== + dependencies: + anymatch "~3.1.2" + braces "~3.0.2" + glob-parent "~5.1.2" + is-binary-path "~2.1.0" + is-glob "~4.0.1" + normalize-path "~3.0.0" + readdirp "~3.6.0" + optionalDependencies: + fsevents "~2.3.2" + +chownr@^1.1.4: + version "1.1.4" + resolved "https://registry.npmjs.org/chownr/-/chownr-1.1.4.tgz" + integrity sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg== + +ci-info@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/ci-info/-/ci-info-2.0.0.tgz" + integrity sha512-5tK7EtrZ0N+OLFMthtqOj4fI2Jeb88C4CAZPu25LDVUgXJ0A3Js4PMGqrn0JU1W0Mh1/Z8wZzYPxqUrXeBboCQ== + +cids@^0.7.1: + version "0.7.5" + resolved "https://registry.npmjs.org/cids/-/cids-0.7.5.tgz" + integrity sha512-zT7mPeghoWAu+ppn8+BS1tQ5qGmbMfB4AregnQjA/qHY3GC1m1ptI9GkWNlgeu38r7CuRdXB47uY2XgAYt6QVA== + dependencies: + buffer "^5.5.0" + class-is "^1.1.0" + multibase "~0.6.0" + multicodec "^1.0.0" + multihashes "~0.4.15" + +cipher-base@^1.0.0, cipher-base@^1.0.1, cipher-base@^1.0.3: + version "1.0.4" + resolved "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.4.tgz" + integrity sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q== + dependencies: + inherits "^2.0.1" + safe-buffer "^5.0.1" + +class-is@^1.1.0: + version "1.1.0" + resolved "https://registry.npmjs.org/class-is/-/class-is-1.1.0.tgz" + integrity sha512-rhjH9AG1fvabIDoGRVH587413LPjTZgmDF9fOFCbFJQV4yuocX1mHxxvXI4g3cGwbVY9wAYIoKlg1N79frJKQw== + +class-utils@^0.3.5: + version "0.3.6" + resolved "https://registry.npmjs.org/class-utils/-/class-utils-0.3.6.tgz" + integrity sha512-qOhPa/Fj7s6TY8H8esGu5QNpMMQxz79h+urzrNYN6mn+9BnxlDGf5QZ+XeCDsxSjPqsSR56XOZOJmpeurnLMeg== + dependencies: + arr-union "^3.1.0" + define-property "^0.2.5" + isobject "^3.0.0" + static-extend "^0.1.1" + +clean-stack@^2.0.0: + version "2.2.0" + resolved "https://registry.npmjs.org/clean-stack/-/clean-stack-2.2.0.tgz" + integrity sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A== + +cli-cursor@^2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/cli-cursor/-/cli-cursor-2.1.0.tgz" + integrity sha1-s12sN2R5+sw+lHR9QdDQ9SOP/LU= + dependencies: + restore-cursor "^2.0.0" + +cli-cursor@^3.1.0: + version "3.1.0" + resolved "https://registry.npmjs.org/cli-cursor/-/cli-cursor-3.1.0.tgz" + integrity sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw== + dependencies: + restore-cursor "^3.1.0" + +cli-table3@^0.5.0: + version "0.5.1" + resolved "https://registry.npmjs.org/cli-table3/-/cli-table3-0.5.1.tgz" + integrity sha512-7Qg2Jrep1S/+Q3EceiZtQcDPWxhAvBw+ERf1162v4sikJrvojMHFqXt8QIVha8UlH9rgU0BeWPytZ9/TzYqlUw== + dependencies: + object-assign "^4.1.0" + string-width "^2.1.1" + optionalDependencies: + colors "^1.1.2" + +cli-truncate@^2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/cli-truncate/-/cli-truncate-2.1.0.tgz" + integrity sha512-n8fOixwDD6b/ObinzTrp1ZKFzbgvKZvuz/TvejnLn1aQfC6r52XEx85FmuC+3HI+JM7coBRXUvNqEU2PHVrHpg== + dependencies: + slice-ansi "^3.0.0" + string-width "^4.2.0" + +cli-truncate@^3.1.0: + version "3.1.0" + resolved "https://registry.npmjs.org/cli-truncate/-/cli-truncate-3.1.0.tgz" + integrity sha512-wfOBkjXteqSnI59oPcJkcPl/ZmwvMMOj340qUIY1SKZCv0B9Cf4D4fAucRkIKQmsIuYK3x1rrgU7MeGRruiuiA== + dependencies: + slice-ansi "^5.0.0" + string-width "^5.0.0" + +cli-width@^2.0.0: + version "2.2.1" + resolved "https://registry.npmjs.org/cli-width/-/cli-width-2.2.1.tgz" + integrity sha512-GRMWDxpOB6Dgk2E5Uo+3eEBvtOOlimMmpbFiKuLFnQzYDavtLFY3K5ona41jgN/WdRZtG7utuVSVTL4HbZHGkw== + +cliui@^3.2.0: + version "3.2.0" + resolved "https://registry.npmjs.org/cliui/-/cliui-3.2.0.tgz" + integrity sha1-EgYBU3qRbSmUD5NNo7SNWFo5IT0= + dependencies: + string-width "^1.0.1" + strip-ansi "^3.0.1" + wrap-ansi "^2.0.0" + +cliui@^5.0.0: + version "5.0.0" + resolved "https://registry.npmjs.org/cliui/-/cliui-5.0.0.tgz" + integrity sha512-PYeGSEmmHM6zvoef2w8TPzlrnNpXIjTipYK780YswmIP9vjxmd6Y2a3CB2Ks6/AU8NHjZugXvo8w3oWM2qnwXA== + dependencies: + string-width "^3.1.0" + strip-ansi "^5.2.0" + wrap-ansi "^5.1.0" + +cliui@^7.0.2: + version "7.0.4" + resolved "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz" + integrity sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ== + dependencies: + string-width "^4.2.0" + strip-ansi "^6.0.0" + wrap-ansi "^7.0.0" + +clone-response@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/clone-response/-/clone-response-1.0.2.tgz" + integrity sha1-0dyXOSAxTfZ/vrlCI7TuNQI56Ws= + dependencies: + mimic-response "^1.0.0" + +clone@2.1.2, clone@^2.0.0: + version "2.1.2" + resolved "https://registry.npmjs.org/clone/-/clone-2.1.2.tgz" + integrity sha1-G39Ln1kfHo+DZwQBYANFoCiHQ18= + +code-point-at@^1.0.0: + version "1.1.0" + resolved "https://registry.npmjs.org/code-point-at/-/code-point-at-1.1.0.tgz" + integrity sha1-DQcLTQQ6W+ozovGkDi7bPZpMz3c= + +collection-visit@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/collection-visit/-/collection-visit-1.0.0.tgz" + integrity sha1-S8A3PBZLwykbTTaMgpzxqApZ3KA= + dependencies: + map-visit "^1.0.0" + object-visit "^1.0.0" + +color-convert@^1.9.0: + version "1.9.3" + resolved "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz" + integrity sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg== + dependencies: + color-name "1.1.3" + +color-convert@^2.0.1: + version "2.0.1" + resolved "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz" + integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ== + dependencies: + color-name "~1.1.4" + +color-name@1.1.3: + version "1.1.3" + resolved "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz" + integrity sha1-p9BVi9icQveV3UIyj3QIMcpTvCU= + +color-name@~1.1.4: + version "1.1.4" + resolved "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz" + integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA== + +colorette@^2.0.16: + version "2.0.16" + resolved "https://registry.npmjs.org/colorette/-/colorette-2.0.16.tgz" + integrity sha512-hUewv7oMjCp+wkBv5Rm0v87eJhq4woh5rSR+42YSQJKecCqgIqNkZ6lAlQms/BwHPJA5NKMRlpxPRv0n8HQW6g== + +colors@1.4.0, colors@^1.1.2: + version "1.4.0" + resolved "https://registry.npmjs.org/colors/-/colors-1.4.0.tgz" + integrity sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA== + +combined-stream@^1.0.6, combined-stream@^1.0.8, combined-stream@~1.0.6: + version "1.0.8" + resolved "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz" + integrity sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg== + dependencies: + delayed-stream "~1.0.0" + +command-exists@^1.2.8: + version "1.2.9" + resolved "https://registry.npmjs.org/command-exists/-/command-exists-1.2.9.tgz" + integrity sha512-LTQ/SGc+s0Xc0Fu5WaKnR0YiygZkm9eKFvyS+fRsU7/ZWFF8ykFM6Pc9aCVf1+xasOOZpO3BAVgVrKvsqKHV7w== + +command-line-args@^4.0.7: + version "4.0.7" + resolved "https://registry.npmjs.org/command-line-args/-/command-line-args-4.0.7.tgz" + integrity sha512-aUdPvQRAyBvQd2n7jXcsMDz68ckBJELXNzBybCHOibUWEg0mWTnaYCSRU8h9R+aNRSvDihJtssSRCiDRpLaezA== + dependencies: + array-back "^2.0.0" + find-replace "^1.0.3" + typical "^2.6.1" + +command-line-args@^5.1.1: + version "5.2.1" + resolved "https://registry.npmjs.org/command-line-args/-/command-line-args-5.2.1.tgz" + integrity sha512-H4UfQhZyakIjC74I9d34fGYDwk3XpSr17QhEd0Q3I9Xq1CETHo4Hcuo87WyWHpAF1aSLjLRf5lD9ZGX2qStUvg== + dependencies: + array-back "^3.1.0" + find-replace "^3.0.0" + lodash.camelcase "^4.3.0" + typical "^4.0.0" + +command-line-usage@^6.1.0: + version "6.1.3" + resolved "https://registry.npmjs.org/command-line-usage/-/command-line-usage-6.1.3.tgz" + integrity sha512-sH5ZSPr+7UStsloltmDh7Ce5fb8XPlHyoPzTpyyMuYCtervL65+ubVZ6Q61cFtFl62UyJlc8/JwERRbAFPUqgw== + dependencies: + array-back "^4.0.2" + chalk "^2.4.2" + table-layout "^1.0.2" + typical "^5.2.0" + +commander@2.18.0: + version "2.18.0" + resolved "https://registry.npmjs.org/commander/-/commander-2.18.0.tgz" + integrity sha512-6CYPa+JP2ftfRU2qkDK+UTVeQYosOg/2GbcjIcKPHfinyOLPVGXu/ovN86RP49Re5ndJK1N0kuiidFFuepc4ZQ== + +commander@3.0.2: + version "3.0.2" + resolved "https://registry.npmjs.org/commander/-/commander-3.0.2.tgz" + integrity sha512-Gar0ASD4BDyKC4hl4DwHqDrmvjoxWKZigVnAbn5H1owvm4CxCPdb0HQDehwNYMJpla5+M2tPmPARzhtYuwpHow== + +commander@^8.3.0: + version "8.3.0" + resolved "https://registry.npmjs.org/commander/-/commander-8.3.0.tgz" + integrity sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww== + +compare-versions@^4.0.0: + version "4.1.3" + resolved "https://registry.yarnpkg.com/compare-versions/-/compare-versions-4.1.3.tgz#8f7b8966aef7dc4282b45dfa6be98434fc18a1a4" + integrity sha512-WQfnbDcrYnGr55UwbxKiQKASnTtNnaAWVi8jZyy8NTpVAXWACSne8lMD1iaIo9AiU6mnuLvSVshCzewVuWxHUg== + +component-emitter@^1.2.1: + version "1.3.0" + resolved "https://registry.npmjs.org/component-emitter/-/component-emitter-1.3.0.tgz" + integrity sha512-Rd3se6QB+sO1TwqZjscQrurpEPIfO0/yYnSin6Q/rD3mOutHvUrCAhJub3r90uNb+SESBuE0QYoB90YdfatsRg== + +concat-map@0.0.1: + version "0.0.1" + resolved "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz" + integrity sha1-2Klr13/Wjfd5OnMDajug1UBdR3s= + +concat-stream@^1.5.1, concat-stream@^1.6.0, concat-stream@^1.6.2: + version "1.6.2" + resolved "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz" + integrity sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw== + dependencies: + buffer-from "^1.0.0" + inherits "^2.0.3" + readable-stream "^2.2.2" + typedarray "^0.0.6" + +content-disposition@0.5.4: + version "0.5.4" + resolved "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz" + integrity sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ== + dependencies: + safe-buffer "5.2.1" + +content-hash@^2.5.2: + version "2.5.2" + resolved "https://registry.npmjs.org/content-hash/-/content-hash-2.5.2.tgz" + integrity sha512-FvIQKy0S1JaWV10sMsA7TRx8bpU+pqPkhbsfvOJAdjRXvYxEckAwQWGwtRjiaJfh+E0DvcWUGqcdjwMGFjsSdw== + dependencies: + cids "^0.7.1" + multicodec "^0.5.5" + multihashes "^0.4.15" + +content-type@~1.0.4: + version "1.0.4" + resolved "https://registry.npmjs.org/content-type/-/content-type-1.0.4.tgz" + integrity sha512-hIP3EEPs8tB9AT1L+NUqtwOAps4mk2Zob89MWXMHjHWg9milF/j4osnnQLXBCBFBk/tvIG/tUc9mOUJiPBhPXA== + +convert-source-map@^1.5.1: + version "1.8.0" + resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-1.8.0.tgz#f3373c32d21b4d780dd8004514684fb791ca4369" + integrity sha512-+OQdjP49zViI/6i7nIJpA8rAl4sV/JdPfU9nZs3VqOwGIgizICvuN2ru6fMd+4llL0tar18UYJXfZ/TWtmhUjA== + dependencies: + safe-buffer "~5.1.1" + +cookie-signature@1.0.6: + version "1.0.6" + resolved "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz" + integrity sha1-4wOogrNCzD7oylE6eZmXNNqzriw= + +cookie@0.5.0: + version "0.5.0" + resolved "https://registry.npmjs.org/cookie/-/cookie-0.5.0.tgz" + integrity sha512-YZ3GUyn/o8gfKJlnlX7g7xq4gyO6OSuhGPKaaGssGB2qgDUS0gPgtTvoyZLTt9Ab6dC4hfc9dV5arkvc/OCmrw== + +cookie@^0.4.1: + version "0.4.2" + resolved "https://registry.npmjs.org/cookie/-/cookie-0.4.2.tgz" + integrity sha512-aSWTXFzaKWkvHO1Ny/s+ePFpvKsPnjc551iI41v3ny/ow6tBG5Vd+FuqGNhh1LxOmVzOlGUriIlOaokOvhaStA== + +cookiejar@^2.1.1: + version "2.1.3" + resolved "https://registry.npmjs.org/cookiejar/-/cookiejar-2.1.3.tgz" + integrity sha512-JxbCBUdrfr6AQjOXrxoTvAMJO4HBTUIlBzslcJPAz+/KT8yk53fXun51u+RenNYvad/+Vc2DIz5o9UxlCDymFQ== + +copy-descriptor@^0.1.0: + version "0.1.1" + resolved "https://registry.npmjs.org/copy-descriptor/-/copy-descriptor-0.1.1.tgz" + integrity sha1-Z29us8OZl8LuGsOpJP1hJHSPV40= + +core-js-pure@^3.0.1: + version "3.22.3" + resolved "https://registry.npmjs.org/core-js-pure/-/core-js-pure-3.22.3.tgz" + integrity sha512-oN88zz7nmKROMy8GOjs+LN+0LedIvbMdnB5XsTlhcOg1WGARt9l0LFg0zohdoFmCsEZ1h2ZbSQ6azj3M+vhzwQ== + +core-js@^2.4.0, core-js@^2.5.0: + version "2.6.12" + resolved "https://registry.npmjs.org/core-js/-/core-js-2.6.12.tgz" + integrity sha512-Kb2wC0fvsWfQrgk8HU5lW6U/Lcs8+9aaYcy4ZFc6DDlo4nZ7n70dEgE5rtR0oG6ufKDUnrwfWL1mXR5ljDatrQ== + +core-util-is@1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz" + integrity sha1-tf1UIgqivFq1eqtxQMlAdUUDwac= + +core-util-is@~1.0.0: + version "1.0.3" + resolved "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz" + integrity sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ== + +cors@^2.8.1: + version "2.8.5" + resolved "https://registry.npmjs.org/cors/-/cors-2.8.5.tgz" + integrity sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g== + dependencies: + object-assign "^4" + vary "^1" + +cosmiconfig@^5.0.7: + version "5.2.1" + resolved "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-5.2.1.tgz" + integrity sha512-H65gsXo1SKjf8zmrJ67eJk8aIRKV5ff2D4uKZIBZShbhGSpEmsQOPW/SKMKYhSTrqR7ufy6RP69rPogdaPh/kA== + dependencies: + import-fresh "^2.0.0" + is-directory "^0.3.1" + js-yaml "^3.13.1" + parse-json "^4.0.0" + +crc-32@^1.2.0: + version "1.2.2" + resolved "https://registry.npmjs.org/crc-32/-/crc-32-1.2.2.tgz" + integrity sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ== + +create-ecdh@^4.0.0: + version "4.0.4" + resolved "https://registry.npmjs.org/create-ecdh/-/create-ecdh-4.0.4.tgz" + integrity sha512-mf+TCx8wWc9VpuxfP2ht0iSISLZnt0JgWlrOKZiNqyUZWnjIaCIVNQArMHnCZKfEYRg6IM7A+NeJoN8gf/Ws0A== + dependencies: + bn.js "^4.1.0" + elliptic "^6.5.3" + +create-hash@^1.1.0, create-hash@^1.1.2, create-hash@^1.2.0: + version "1.2.0" + resolved "https://registry.npmjs.org/create-hash/-/create-hash-1.2.0.tgz" + integrity sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg== + dependencies: + cipher-base "^1.0.1" + inherits "^2.0.1" + md5.js "^1.3.4" + ripemd160 "^2.0.1" + sha.js "^2.4.0" + +create-hmac@^1.1.0, create-hmac@^1.1.4, create-hmac@^1.1.7: + version "1.1.7" + resolved "https://registry.npmjs.org/create-hmac/-/create-hmac-1.1.7.tgz" + integrity sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg== + dependencies: + cipher-base "^1.0.3" + create-hash "^1.1.0" + inherits "^2.0.1" + ripemd160 "^2.0.0" + safe-buffer "^5.0.1" + sha.js "^2.4.8" + +create-require@^1.1.0: + version "1.1.1" + resolved "https://registry.npmjs.org/create-require/-/create-require-1.1.1.tgz" + integrity sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ== + +cross-fetch@>=3.1.5, cross-fetch@^2.1.0, cross-fetch@^2.1.1: + version "3.1.5" + resolved "https://registry.yarnpkg.com/cross-fetch/-/cross-fetch-3.1.5.tgz#e1389f44d9e7ba767907f7af8454787952ab534f" + integrity sha512-lvb1SBsI0Z7GDwmuid+mU3kWVBwTVUbe7S0H52yaaAdQOXq2YktTCZdlAcNKFzE6QtRz0snpw9bNiPeOIkkQvw== + dependencies: + node-fetch "2.6.7" + +cross-spawn@^6.0.5: + version "6.0.5" + resolved "https://registry.npmjs.org/cross-spawn/-/cross-spawn-6.0.5.tgz" + integrity sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ== + dependencies: + nice-try "^1.0.4" + path-key "^2.0.1" + semver "^5.5.0" + shebang-command "^1.2.0" + which "^1.2.9" + +cross-spawn@^7.0.2, cross-spawn@^7.0.3: + version "7.0.3" + resolved "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz" + integrity sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w== + dependencies: + path-key "^3.1.0" + shebang-command "^2.0.0" + which "^2.0.1" + +"crypt@>= 0.0.1": + version "0.0.2" + resolved "https://registry.npmjs.org/crypt/-/crypt-0.0.2.tgz" + integrity sha1-iNf/fsDfuG9xPch7u0LQRNPmxBs= + +crypto-browserify@3.12.0: + version "3.12.0" + resolved "https://registry.npmjs.org/crypto-browserify/-/crypto-browserify-3.12.0.tgz" + integrity sha512-fz4spIh+znjO2VjL+IdhEpRJ3YN6sMzITSBijk6FK2UvTqruSQW+/cCZTSNsMiZNvUeq0CqurF+dAbyiGOY6Wg== + dependencies: + browserify-cipher "^1.0.0" + browserify-sign "^4.0.0" + create-ecdh "^4.0.0" + create-hash "^1.1.0" + create-hmac "^1.1.0" + diffie-hellman "^5.0.0" + inherits "^2.0.1" + pbkdf2 "^3.0.3" + public-encrypt "^4.0.0" + randombytes "^2.0.0" + randomfill "^1.0.3" + +d@1, d@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/d/-/d-1.0.1.tgz" + integrity sha512-m62ShEObQ39CfralilEQRjH6oAMtNCV1xJyEx5LpRYUVN+EviphDgUc/F3hnYbADmkiNs67Y+3ylmlG7Lnu+FA== + dependencies: + es5-ext "^0.10.50" + type "^1.0.1" + +dashdash@^1.12.0: + version "1.14.1" + resolved "https://registry.npmjs.org/dashdash/-/dashdash-1.14.1.tgz" + integrity sha1-hTz6D3y+L+1d4gMmuN1YEDX24vA= + dependencies: + assert-plus "^1.0.0" + +data-uri-to-buffer@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-4.0.0.tgz" + integrity sha512-Vr3mLBA8qWmcuschSLAOogKgQ/Jwxulv3RNE4FXnYWRGujzrRWQI4m12fQqRkwX06C0KanhLr4hK+GydchZsaA== + +death@^1.1.0: + version "1.1.0" + resolved "https://registry.npmjs.org/death/-/death-1.1.0.tgz" + integrity sha1-AaqcQB7dknUFFEcLgmY5DGbGcxg= + +debug@2.6.9, debug@^2.2.0, debug@^2.3.3, debug@^2.6.0, debug@^2.6.8, debug@^2.6.9: + version "2.6.9" + resolved "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz" + integrity sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA== + dependencies: + ms "2.0.0" + +debug@3.2.6: + version "3.2.6" + resolved "https://registry.npmjs.org/debug/-/debug-3.2.6.tgz" + integrity sha512-mel+jf7nrtEl5Pn1Qx46zARXKDpBbvzezse7p7LqINmdoIk8PYP5SySaxEmYv6TZ0JyEKA1hsCId6DIhgITtWQ== + dependencies: + ms "^2.1.1" + +debug@4, debug@^4.0.1, debug@^4.1.1, debug@^4.3.1, debug@^4.3.2, debug@^4.3.3: + version "4.3.4" + resolved "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz" + integrity sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ== + dependencies: + ms "2.1.2" + +debug@4.3.3: + version "4.3.3" + resolved "https://registry.npmjs.org/debug/-/debug-4.3.3.tgz" + integrity sha512-/zxw5+vh1Tfv+4Qn7a5nsbcJKPaSvCDhojn6FEl9vupwK2VCSDtEiEtqr8DFtzYFOdz63LBkxec7DYuc2jon6Q== + dependencies: + ms "2.1.2" + +debug@^3.1.0, debug@^3.2.7: + version "3.2.7" + resolved "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz" + integrity sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ== + dependencies: + ms "^2.1.1" + +decamelize@^1.1.1: + version "1.2.0" + resolved "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz" + integrity sha1-9lNNFRSCabIDUue+4m9QH5oZEpA= + +decamelize@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/decamelize/-/decamelize-4.0.0.tgz" + integrity sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ== + +decimal.js-light@^2.5.0: + version "2.5.1" + resolved "https://registry.yarnpkg.com/decimal.js-light/-/decimal.js-light-2.5.1.tgz#134fd32508f19e208f4fb2f8dac0d2626a867934" + integrity sha512-qIMFpTMZmny+MMIitAB6D7iVPEorVw6YQRWkvarTkT4tBeSLLiHzcwj6q0MmYSFCiVpiqPJTJEYIrpcPzVEIvg== + +decode-uri-component@^0.2.0: + version "0.2.0" + resolved "https://registry.npmjs.org/decode-uri-component/-/decode-uri-component-0.2.0.tgz" + integrity sha1-6zkTMzRYd1y4TNGh+uBiEGu4dUU= + +decompress-response@^3.2.0, decompress-response@^3.3.0: + version "3.3.0" + resolved "https://registry.npmjs.org/decompress-response/-/decompress-response-3.3.0.tgz" + integrity sha1-gKTdMjdIOEv6JICDYirt7Jgq3/M= + dependencies: + mimic-response "^1.0.0" + +deep-eql@^3.0.1: + version "3.0.1" + resolved "https://registry.npmjs.org/deep-eql/-/deep-eql-3.0.1.tgz" + integrity sha512-+QeIQyN5ZuO+3Uk5DYh6/1eKO0m0YmJFGNmFHGACpf1ClL1nmlV/p4gNgbl2pJGxgXb4faqo6UE+M5ACEMyVcw== + dependencies: + type-detect "^4.0.0" + +deep-equal@~1.1.1: + version "1.1.1" + resolved "https://registry.npmjs.org/deep-equal/-/deep-equal-1.1.1.tgz" + integrity sha512-yd9c5AdiqVcR+JjcwUQb9DkhJc8ngNr0MahEBGvDiJw8puWab2yZlh+nkasOnZP+EGTAP6rRp2JzJhJZzvNF8g== + dependencies: + is-arguments "^1.0.4" + is-date-object "^1.0.1" + is-regex "^1.0.4" + object-is "^1.0.1" + object-keys "^1.1.1" + regexp.prototype.flags "^1.2.0" + +deep-extend@~0.6.0: + version "0.6.0" + resolved "https://registry.npmjs.org/deep-extend/-/deep-extend-0.6.0.tgz" + integrity sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA== + +deep-is@^0.1.3, deep-is@~0.1.3: + version "0.1.4" + resolved "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz" + integrity sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ== + +defer-to-connect@^1.0.1: + version "1.1.3" + resolved "https://registry.npmjs.org/defer-to-connect/-/defer-to-connect-1.1.3.tgz" + integrity sha512-0ISdNousHvZT2EiFlZeZAHBUvSxmKswVCEf8hW7KWgG4a8MVEu/3Vb6uWYozkjylyCxe0JBIiRB1jV45S70WVQ== + +deferred-leveldown@~1.2.1: + version "1.2.2" + resolved "https://registry.npmjs.org/deferred-leveldown/-/deferred-leveldown-1.2.2.tgz" + integrity sha512-uukrWD2bguRtXilKt6cAWKyoXrTSMo5m7crUdLfWQmu8kIm88w3QZoUL+6nhpfKVmhHANER6Re3sKoNoZ3IKMA== + dependencies: + abstract-leveldown "~2.6.0" + +deferred-leveldown@~4.0.0: + version "4.0.2" + resolved "https://registry.npmjs.org/deferred-leveldown/-/deferred-leveldown-4.0.2.tgz" + integrity sha512-5fMC8ek8alH16QiV0lTCis610D1Zt1+LA4MS4d63JgS32lrCjTFDUFz2ao09/j2I4Bqb5jL4FZYwu7Jz0XO1ww== + dependencies: + abstract-leveldown "~5.0.0" + inherits "^2.0.3" + +deferred-leveldown@~5.3.0: + version "5.3.0" + resolved "https://registry.npmjs.org/deferred-leveldown/-/deferred-leveldown-5.3.0.tgz" + integrity sha512-a59VOT+oDy7vtAbLRCZwWgxu2BaCfd5Hk7wxJd48ei7I+nsg8Orlb9CLG0PMZienk9BSUKgeAqkO2+Lw+1+Ukw== + dependencies: + abstract-leveldown "~6.2.1" + inherits "^2.0.3" + +define-properties@^1.1.2, define-properties@^1.1.3, define-properties@^1.1.4: + version "1.1.4" + resolved "https://registry.npmjs.org/define-properties/-/define-properties-1.1.4.tgz" + integrity sha512-uckOqKcfaVvtBdsVkdPv3XjveQJsNQqmhXgRi8uhvWWuPYZCNlzT8qAyblUgNoXdHdjMTzAqeGjAoli8f+bzPA== + dependencies: + has-property-descriptors "^1.0.0" + object-keys "^1.1.1" + +define-property@^0.2.5: + version "0.2.5" + resolved "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz" + integrity sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY= + dependencies: + is-descriptor "^0.1.0" + +define-property@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz" + integrity sha1-dp66rz9KY6rTr56NMEybvnm/sOY= + dependencies: + is-descriptor "^1.0.0" + +define-property@^2.0.2: + version "2.0.2" + resolved "https://registry.npmjs.org/define-property/-/define-property-2.0.2.tgz" + integrity sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ== + dependencies: + is-descriptor "^1.0.2" + isobject "^3.0.1" + +defined@~1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/defined/-/defined-1.0.0.tgz" + integrity sha1-yY2bzvdWdBiOEQlpFRGZ45sfppM= + +delayed-stream@~1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz" + integrity sha1-3zrhmayt+31ECqrgsp4icrJOxhk= + +depd@2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz" + integrity sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw== + +des.js@^1.0.0: + version "1.0.1" + resolved "https://registry.npmjs.org/des.js/-/des.js-1.0.1.tgz" + integrity sha512-Q0I4pfFrv2VPd34/vfLrFOoRmlYj3OV50i7fskps1jZWK1kApMWWT9G6RRUeYedLcBDIhnSDaUvJMb3AhUlaEA== + dependencies: + inherits "^2.0.1" + minimalistic-assert "^1.0.0" + +destroy@1.2.0: + version "1.2.0" + resolved "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz" + integrity sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg== + +detect-indent@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/detect-indent/-/detect-indent-4.0.0.tgz" + integrity sha1-920GQ1LN9Docts5hnE7jqUdd4gg= + dependencies: + repeating "^2.0.0" + +detect-port@^1.3.0: + version "1.3.0" + resolved "https://registry.npmjs.org/detect-port/-/detect-port-1.3.0.tgz" + integrity sha512-E+B1gzkl2gqxt1IhUzwjrxBKRqx1UzC3WLONHinn8S3T6lwV/agVCyitiFOsGJ/eYuEUBvD71MZHy3Pv1G9doQ== + dependencies: + address "^1.0.1" + debug "^2.6.0" + +diff@3.5.0: + version "3.5.0" + resolved "https://registry.npmjs.org/diff/-/diff-3.5.0.tgz" + integrity sha512-A46qtFgd+g7pDZinpnwiRJtxbC1hpgf0uzP3iG89scHk0AUC7A1TGxf5OiiOUv/JMZR8GOt8hL900hV0bOy5xA== + +diff@5.0.0: + version "5.0.0" + resolved "https://registry.npmjs.org/diff/-/diff-5.0.0.tgz" + integrity sha512-/VTCrvm5Z0JGty/BWHljh+BAiw3IK+2j87NGMu8Nwc/f48WoDAC395uomO9ZD117ZOBaHmkX1oyLvkVM/aIT3w== + +diff@^4.0.1: + version "4.0.2" + resolved "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz" + integrity sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A== + +diffie-hellman@^5.0.0: + version "5.0.3" + resolved "https://registry.npmjs.org/diffie-hellman/-/diffie-hellman-5.0.3.tgz" + integrity sha512-kqag/Nl+f3GwyK25fhUMYj81BUOrZ9IuJsjIcDE5icNM9FJHAVm3VcUDxdLPoQtTuUylWm6ZIknYJwwaPxsUzg== + dependencies: + bn.js "^4.1.0" + miller-rabin "^4.0.0" + randombytes "^2.0.0" + +dir-glob@^3.0.1: + version "3.0.1" + resolved "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz" + integrity sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA== + dependencies: + path-type "^4.0.0" + +doctrine@^2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz" + integrity sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw== + dependencies: + esutils "^2.0.2" + +doctrine@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz" + integrity sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w== + dependencies: + esutils "^2.0.2" + +dom-walk@^0.1.0: + version "0.1.2" + resolved "https://registry.npmjs.org/dom-walk/-/dom-walk-0.1.2.tgz" + integrity sha512-6QvTW9mrGeIegrFXdtQi9pk7O/nSK6lSdXW2eqUspN5LWD7UTji2Fqw5V2YLjBpHEoU9Xl/eUWNpDeZvoyOv2w== + +dotenv@^16.0.0: + version "16.0.0" + resolved "https://registry.npmjs.org/dotenv/-/dotenv-16.0.0.tgz" + integrity sha512-qD9WU0MPM4SWLPJy/r2Be+2WgQj8plChsyrCNQzW/0WjvcJQiKQJ9mH3ZgB3fxbUUxgc/11ZJ0Fi5KiimWGz2Q== + +dotignore@~0.1.2: + version "0.1.2" + resolved "https://registry.npmjs.org/dotignore/-/dotignore-0.1.2.tgz" + integrity sha512-UGGGWfSauusaVJC+8fgV+NVvBXkCTmVv7sk6nojDZZvuOUNGUy0Zk4UpHQD6EDjS0jpBwcACvH4eofvyzBcRDw== + dependencies: + minimatch "^3.0.4" + +duplexer3@^0.1.4: + version "0.1.4" + resolved "https://registry.npmjs.org/duplexer3/-/duplexer3-0.1.4.tgz" + integrity sha1-7gHdHKwO08vH/b6jfcCo8c4ALOI= + +eastasianwidth@^0.2.0: + version "0.2.0" + resolved "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz" + integrity sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA== + +ecc-jsbn@~0.1.1: + version "0.1.2" + resolved "https://registry.npmjs.org/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz" + integrity sha1-OoOpBOVDUyh4dMVkt1SThoSamMk= + dependencies: + jsbn "~0.1.0" + safer-buffer "^2.1.0" + +ee-first@1.1.1: + version "1.1.1" + resolved "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz" + integrity sha1-WQxhFWsK4vTwJVcyoViyZrxWsh0= + +electron-to-chromium@^1.3.47: + version "1.4.137" + resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.137.tgz#186180a45617283f1c012284458510cd99d6787f" + integrity sha512-0Rcpald12O11BUogJagX3HsCN3FE83DSqWjgXoHo5a72KUKMSfI39XBgJpgNNxS9fuGzytaFjE06kZkiVFy2qA== + +elliptic@6.5.4, elliptic@^6.4.0, elliptic@^6.5.2, elliptic@^6.5.3, elliptic@^6.5.4: + version "6.5.4" + resolved "https://registry.npmjs.org/elliptic/-/elliptic-6.5.4.tgz" + integrity sha512-iLhC6ULemrljPZb+QutR5TQGB+pdW6KGD5RSegS+8sorOZT+rdQFbsQFJgvN3eRqNALqJer4oQ16YvJHlU8hzQ== + dependencies: + bn.js "^4.11.9" + brorand "^1.1.0" + hash.js "^1.0.0" + hmac-drbg "^1.0.1" + inherits "^2.0.4" + minimalistic-assert "^1.0.1" + minimalistic-crypto-utils "^1.0.1" + +emoji-regex@^10.0.0: + version "10.1.0" + resolved "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.1.0.tgz" + integrity sha512-xAEnNCT3w2Tg6MA7ly6QqYJvEoY1tm9iIjJ3yMKK9JPlWuRHAMoe5iETwQnx3M9TVbFMfsrBgWKR+IsmswwNjg== + +emoji-regex@^7.0.1: + version "7.0.3" + resolved "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz" + integrity sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA== + +emoji-regex@^8.0.0: + version "8.0.0" + resolved "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz" + integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A== + +emoji-regex@^9.2.2: + version "9.2.2" + resolved "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz" + integrity sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg== + +encode-utf8@^1.0.2: + version "1.0.3" + resolved "https://registry.yarnpkg.com/encode-utf8/-/encode-utf8-1.0.3.tgz#f30fdd31da07fb596f281beb2f6b027851994cda" + integrity sha512-ucAnuBEhUK4boH2HjVYG5Q2mQyPorvv0u/ocS+zhdw0S8AlHYY+GOFhP1Gio5z4icpP2ivFSvhtFjQi8+T9ppw== + +encodeurl@~1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz" + integrity sha1-rT/0yG7C0CkyL1oCw6mmBslbP1k= + +encoding-down@5.0.4, encoding-down@~5.0.0: + version "5.0.4" + resolved "https://registry.npmjs.org/encoding-down/-/encoding-down-5.0.4.tgz" + integrity sha512-8CIZLDcSKxgzT+zX8ZVfgNbu8Md2wq/iqa1Y7zyVR18QBEAc0Nmzuvj/N5ykSKpfGzjM8qxbaFntLPwnVoUhZw== + dependencies: + abstract-leveldown "^5.0.0" + inherits "^2.0.3" + level-codec "^9.0.0" + level-errors "^2.0.0" + xtend "^4.0.1" + +encoding-down@^6.3.0: + version "6.3.0" + resolved "https://registry.npmjs.org/encoding-down/-/encoding-down-6.3.0.tgz" + integrity sha512-QKrV0iKR6MZVJV08QY0wp1e7vF6QbhnbQhb07bwpEyuz4uZiZgPlEGdkCROuFkUwdxlFaiPIhjyarH1ee/3vhw== + dependencies: + abstract-leveldown "^6.2.1" + inherits "^2.0.3" + level-codec "^9.0.0" + level-errors "^2.0.0" + +end-of-stream@^1.1.0: + version "1.4.4" + resolved "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.4.tgz" + integrity sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q== + dependencies: + once "^1.4.0" + +enquirer@^2.3.0, enquirer@^2.3.6: + version "2.3.6" + resolved "https://registry.npmjs.org/enquirer/-/enquirer-2.3.6.tgz" + integrity sha512-yjNnPr315/FjS4zIsUxYguYUPP2e1NK4d7E7ZOLiyYCcbFBiTMyID+2wvm2w6+pZ/odMA7cRkjhsPbltwBOrLg== + dependencies: + ansi-colors "^4.1.1" + +env-paths@^2.2.0: + version "2.2.1" + resolved "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz" + integrity sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A== + +errno@~0.1.1: + version "0.1.8" + resolved "https://registry.npmjs.org/errno/-/errno-0.1.8.tgz" + integrity sha512-dJ6oBr5SQ1VSd9qkk7ByRgb/1SH4JZjCHSW/mr63/QcXO9zLVxvJ6Oy13nio03rxpSnVDDjFor75SjVeZWPW/A== + dependencies: + prr "~1.0.1" + +error-ex@^1.2.0, error-ex@^1.3.1: + version "1.3.2" + resolved "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz" + integrity sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g== + dependencies: + is-arrayish "^0.2.1" + +es-abstract@^1.18.5, es-abstract@^1.19.1, es-abstract@^1.19.2: + version "1.19.5" + resolved "https://registry.npmjs.org/es-abstract/-/es-abstract-1.19.5.tgz" + integrity sha512-Aa2G2+Rd3b6kxEUKTF4TaW67czBLyAv3z7VOhYRU50YBx+bbsYZ9xQP4lMNazePuFlybXI0V4MruPos7qUo5fA== + dependencies: + call-bind "^1.0.2" + es-to-primitive "^1.2.1" + function-bind "^1.1.1" + get-intrinsic "^1.1.1" + get-symbol-description "^1.0.0" + has "^1.0.3" + has-symbols "^1.0.3" + internal-slot "^1.0.3" + is-callable "^1.2.4" + is-negative-zero "^2.0.2" + is-regex "^1.1.4" + is-shared-array-buffer "^1.0.2" + is-string "^1.0.7" + is-weakref "^1.0.2" + object-inspect "^1.12.0" + object-keys "^1.1.1" + object.assign "^4.1.2" + string.prototype.trimend "^1.0.4" + string.prototype.trimstart "^1.0.4" + unbox-primitive "^1.0.1" + +es-abstract@^1.19.0, es-abstract@^1.19.5: + version "1.20.0" + resolved "https://registry.yarnpkg.com/es-abstract/-/es-abstract-1.20.0.tgz#b2d526489cceca004588296334726329e0a6bfb6" + integrity sha512-URbD8tgRthKD3YcC39vbvSDrX23upXnPcnGAjQfgxXF5ID75YcENawc9ZX/9iTP9ptUyfCLIxTTuMYoRfiOVKA== + dependencies: + call-bind "^1.0.2" + es-to-primitive "^1.2.1" + function-bind "^1.1.1" + function.prototype.name "^1.1.5" + get-intrinsic "^1.1.1" + get-symbol-description "^1.0.0" + has "^1.0.3" + has-property-descriptors "^1.0.0" + has-symbols "^1.0.3" + internal-slot "^1.0.3" + is-callable "^1.2.4" + is-negative-zero "^2.0.2" + is-regex "^1.1.4" + is-shared-array-buffer "^1.0.2" + is-string "^1.0.7" + is-weakref "^1.0.2" + object-inspect "^1.12.0" + object-keys "^1.1.1" + object.assign "^4.1.2" + regexp.prototype.flags "^1.4.1" + string.prototype.trimend "^1.0.5" + string.prototype.trimstart "^1.0.5" + unbox-primitive "^1.0.2" + +es-shim-unscopables@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/es-shim-unscopables/-/es-shim-unscopables-1.0.0.tgz" + integrity sha512-Jm6GPcCdC30eMLbZ2x8z2WuRwAws3zTBBKuusffYVUrNj/GVSUAZ+xKMaUpfNDR5IbyNA5LJbaecoUVbmUcB1w== + dependencies: + has "^1.0.3" + +es-to-primitive@^1.2.1: + version "1.2.1" + resolved "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.1.tgz" + integrity sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA== + dependencies: + is-callable "^1.1.4" + is-date-object "^1.0.1" + is-symbol "^1.0.2" + +es5-ext@^0.10.35, es5-ext@^0.10.50: + version "0.10.61" + resolved "https://registry.npmjs.org/es5-ext/-/es5-ext-0.10.61.tgz" + integrity sha512-yFhIqQAzu2Ca2I4SE2Au3rxVfmohU9Y7wqGR+s7+H7krk26NXhIRAZDgqd6xqjCEFUomDEA3/Bo/7fKmIkW1kA== + dependencies: + es6-iterator "^2.0.3" + es6-symbol "^3.1.3" + next-tick "^1.1.0" + +es6-iterator@^2.0.3: + version "2.0.3" + resolved "https://registry.npmjs.org/es6-iterator/-/es6-iterator-2.0.3.tgz" + integrity sha1-p96IkUGgWpSwhUQDstCg+/qY87c= + dependencies: + d "1" + es5-ext "^0.10.35" + es6-symbol "^3.1.1" + +es6-symbol@^3.1.1, es6-symbol@^3.1.3: + version "3.1.3" + resolved "https://registry.npmjs.org/es6-symbol/-/es6-symbol-3.1.3.tgz" + integrity sha512-NJ6Yn3FuDinBaBRWl/q5X/s4koRHBrgKAu+yGI6JCBeiu3qrcbJhwT2GeR/EXVfylRk8dpQVJoLEFhK+Mu31NA== + dependencies: + d "^1.0.1" + ext "^1.1.2" + +escalade@^3.1.1: + version "3.1.1" + resolved "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz" + integrity sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw== + +escape-html@~1.0.3: + version "1.0.3" + resolved "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz" + integrity sha1-Aljq5NPQwJdN4cFpGI7wBR0dGYg= + +escape-string-regexp@1.0.5, escape-string-regexp@^1.0.2, escape-string-regexp@^1.0.5: + version "1.0.5" + resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz" + integrity sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ= + +escape-string-regexp@4.0.0, escape-string-regexp@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz" + integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA== + +escodegen@1.8.x: + version "1.8.1" + resolved "https://registry.npmjs.org/escodegen/-/escodegen-1.8.1.tgz" + integrity sha1-WltTr0aTEQvrsIZ6o0MN07cKEBg= + dependencies: + esprima "^2.7.1" + estraverse "^1.9.1" + esutils "^2.0.2" + optionator "^0.8.1" + optionalDependencies: + source-map "~0.2.0" + +eslint-config-prettier@^8.3.0: + version "8.5.0" + resolved "https://registry.npmjs.org/eslint-config-prettier/-/eslint-config-prettier-8.5.0.tgz" + integrity sha512-obmWKLUNCnhtQRKc+tmnYuQl0pFU1ibYJQ5BGhTVB08bHe9wC8qUeG7c08dj9XX+AuPj1YSGSQIHl1pnDHZR0Q== + +eslint-config-standard@^17.0.0: + version "17.0.0" + resolved "https://registry.yarnpkg.com/eslint-config-standard/-/eslint-config-standard-17.0.0.tgz#fd5b6cf1dcf6ba8d29f200c461de2e19069888cf" + integrity sha512-/2ks1GKyqSOkH7JFvXJicu0iMpoojkwB+f5Du/1SC0PtBL+s8v30k9njRZ21pm2drKYm2342jFnGWzttxPmZVg== + +eslint-import-resolver-node@^0.3.6: + version "0.3.6" + resolved "https://registry.npmjs.org/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.6.tgz" + integrity sha512-0En0w03NRVMn9Uiyn8YRPDKvWjxCWkslUEhGNTdGx15RvPJYQ+lbOlqrlNI2vEAs4pDYK4f/HN2TbDmk5TP0iw== + dependencies: + debug "^3.2.7" + resolve "^1.20.0" + +eslint-module-utils@^2.7.3: + version "2.7.3" + resolved "https://registry.npmjs.org/eslint-module-utils/-/eslint-module-utils-2.7.3.tgz" + integrity sha512-088JEC7O3lDZM9xGe0RerkOMd0EjFl+Yvd1jPWIkMT5u3H9+HC34mWWPnqPrN13gieT9pBOO+Qt07Nb/6TresQ== + dependencies: + debug "^3.2.7" + find-up "^2.1.0" + +eslint-plugin-es@^4.1.0: + version "4.1.0" + resolved "https://registry.yarnpkg.com/eslint-plugin-es/-/eslint-plugin-es-4.1.0.tgz#f0822f0c18a535a97c3e714e89f88586a7641ec9" + integrity sha512-GILhQTnjYE2WorX5Jyi5i4dz5ALWxBIdQECVQavL6s7cI76IZTDWleTHkxz/QT3kvcs2QlGHvKLYsSlPOlPXnQ== + dependencies: + eslint-utils "^2.0.0" + regexpp "^3.0.0" + +eslint-plugin-import@^2.25.4: + version "2.26.0" + resolved "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.26.0.tgz" + integrity sha512-hYfi3FXaM8WPLf4S1cikh/r4IxnO6zrhZbEGz2b660EJRbuxgpDS5gkCuYgGWg2xxh2rBuIr4Pvhve/7c31koA== + dependencies: + array-includes "^3.1.4" + array.prototype.flat "^1.2.5" + debug "^2.6.9" + doctrine "^2.1.0" + eslint-import-resolver-node "^0.3.6" + eslint-module-utils "^2.7.3" + has "^1.0.3" + is-core-module "^2.8.1" + is-glob "^4.0.3" + minimatch "^3.1.2" + object.values "^1.1.5" + resolve "^1.22.0" + tsconfig-paths "^3.14.1" + +eslint-plugin-n@^15.2.0: + version "15.2.1" + resolved "https://registry.yarnpkg.com/eslint-plugin-n/-/eslint-plugin-n-15.2.1.tgz#e62cf800da076ac5a970eb7554efa2136ebfa194" + integrity sha512-uMG50pvKqXK9ab163bSI5OpyZR0F5yIB0pEC4ciGpBLrXVjVDOlx5oTq8GQULWzbelJt7wL5Rw4T+FfAff5Cxg== + dependencies: + builtins "^5.0.1" + eslint-plugin-es "^4.1.0" + eslint-utils "^3.0.0" + ignore "^5.1.1" + is-core-module "^2.9.0" + minimatch "^3.1.2" + resolve "^1.10.1" + semver "^7.3.7" + +eslint-plugin-prettier@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/eslint-plugin-prettier/-/eslint-plugin-prettier-4.0.0.tgz" + integrity sha512-98MqmCJ7vJodoQK359bqQWaxOE0CS8paAz/GgjaZLyex4TTk3g9HugoO89EqWCrFiOqn9EVvcoo7gZzONCWVwQ== + dependencies: + prettier-linter-helpers "^1.0.0" + +eslint-plugin-promise@^6.0.0: + version "6.0.0" + resolved "https://registry.npmjs.org/eslint-plugin-promise/-/eslint-plugin-promise-6.0.0.tgz" + integrity sha512-7GPezalm5Bfi/E22PnQxDWH2iW9GTvAlUNTztemeHb6c1BniSyoeTrM87JkC0wYdi6aQrZX9p2qEiAno8aTcbw== + +eslint-scope@^4.0.3: + version "4.0.3" + resolved "https://registry.npmjs.org/eslint-scope/-/eslint-scope-4.0.3.tgz" + integrity sha512-p7VutNr1O/QrxysMo3E45FjYDTeXBy0iTltPFNSqKAIfjDSXC+4dj+qfyuD8bfAXrW/y6lW3O76VaYNPKfpKrg== + dependencies: + esrecurse "^4.1.0" + estraverse "^4.1.1" + +eslint-scope@^5.1.1: + version "5.1.1" + resolved "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz" + integrity sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw== + dependencies: + esrecurse "^4.3.0" + estraverse "^4.1.1" + +eslint-scope@^7.1.1: + version "7.1.1" + resolved "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.1.1.tgz" + integrity sha512-QKQM/UXpIiHcLqJ5AOyIW7XZmzjkzQXYE54n1++wb0u9V/abW3l9uQnxX8Z5Xd18xyKIMTUAyQ0k1e8pz6LUrw== + dependencies: + esrecurse "^4.3.0" + estraverse "^5.2.0" + +eslint-utils@^1.3.1: + version "1.4.3" + resolved "https://registry.npmjs.org/eslint-utils/-/eslint-utils-1.4.3.tgz" + integrity sha512-fbBN5W2xdY45KulGXmLHZ3c3FHfVYmKg0IrAKGOkT/464PQsx2UeIzfz1RmEci+KLm1bBaAzZAh8+/E+XAeZ8Q== + dependencies: + eslint-visitor-keys "^1.1.0" + +eslint-utils@^2.0.0: + version "2.1.0" + resolved "https://registry.npmjs.org/eslint-utils/-/eslint-utils-2.1.0.tgz" + integrity sha512-w94dQYoauyvlDc43XnGB8lU3Zt713vNChgt4EWwhXAP2XkBvndfxF0AgIqKOOasjPIPzj9JqgwkwbCYD0/V3Zg== + dependencies: + eslint-visitor-keys "^1.1.0" + +eslint-utils@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/eslint-utils/-/eslint-utils-3.0.0.tgz" + integrity sha512-uuQC43IGctw68pJA1RgbQS8/NP7rch6Cwd4j3ZBtgo4/8Flj4eGE7ZYSZRN3iq5pVUv6GPdW5Z1RFleo84uLDA== + dependencies: + eslint-visitor-keys "^2.0.0" + +eslint-visitor-keys@^1.0.0, eslint-visitor-keys@^1.1.0: + version "1.3.0" + resolved "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-1.3.0.tgz" + integrity sha512-6J72N8UNa462wa/KFODt/PJ3IU60SDpC3QXC1Hjc1BXXpfL2C9R5+AU7jhe0F6GREqVMh4Juu+NY7xn+6dipUQ== + +eslint-visitor-keys@^2.0.0: + version "2.1.0" + resolved "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz" + integrity sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw== + +eslint-visitor-keys@^3.0.0, eslint-visitor-keys@^3.3.0: + version "3.3.0" + resolved "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.3.0.tgz" + integrity sha512-mQ+suqKJVyeuwGYHAdjMFqjCyfl8+Ldnxuyp3ldiMBFKkvytrXUZWaiPCEav8qDHKty44bD+qV1IP4T+w+xXRA== + +eslint@^5.6.0: + version "5.16.0" + resolved "https://registry.npmjs.org/eslint/-/eslint-5.16.0.tgz" + integrity sha512-S3Rz11i7c8AA5JPv7xAH+dOyq/Cu/VXHiHXBPOU1k/JAM5dXqQPt3qcrhpHSorXmrpu2g0gkIBVXAqCpzfoZIg== + dependencies: + "@babel/code-frame" "^7.0.0" + ajv "^6.9.1" + chalk "^2.1.0" + cross-spawn "^6.0.5" + debug "^4.0.1" + doctrine "^3.0.0" + eslint-scope "^4.0.3" + eslint-utils "^1.3.1" + eslint-visitor-keys "^1.0.0" + espree "^5.0.1" + esquery "^1.0.1" + esutils "^2.0.2" + file-entry-cache "^5.0.1" + functional-red-black-tree "^1.0.1" + glob "^7.1.2" + globals "^11.7.0" + ignore "^4.0.6" + import-fresh "^3.0.0" + imurmurhash "^0.1.4" + inquirer "^6.2.2" + js-yaml "^3.13.0" + json-stable-stringify-without-jsonify "^1.0.1" + levn "^0.3.0" + lodash "^4.17.11" + minimatch "^3.0.4" + mkdirp "^0.5.1" + natural-compare "^1.4.0" + optionator "^0.8.2" + path-is-inside "^1.0.2" + progress "^2.0.0" + regexpp "^2.0.1" + semver "^5.5.1" + strip-ansi "^4.0.0" + strip-json-comments "^2.0.1" + table "^5.2.3" + text-table "^0.2.0" + +eslint@^8.6.0: + version "8.14.0" + resolved "https://registry.npmjs.org/eslint/-/eslint-8.14.0.tgz" + integrity sha512-3/CE4aJX7LNEiE3i6FeodHmI/38GZtWCsAtsymScmzYapx8q1nVVb+eLcLSzATmCPXw5pT4TqVs1E0OmxAd9tw== + dependencies: + "@eslint/eslintrc" "^1.2.2" + "@humanwhocodes/config-array" "^0.9.2" + ajv "^6.10.0" + chalk "^4.0.0" + cross-spawn "^7.0.2" + debug "^4.3.2" + doctrine "^3.0.0" + escape-string-regexp "^4.0.0" + eslint-scope "^7.1.1" + eslint-utils "^3.0.0" + eslint-visitor-keys "^3.3.0" + espree "^9.3.1" + esquery "^1.4.0" + esutils "^2.0.2" + fast-deep-equal "^3.1.3" + file-entry-cache "^6.0.1" + functional-red-black-tree "^1.0.1" + glob-parent "^6.0.1" + globals "^13.6.0" + ignore "^5.2.0" + import-fresh "^3.0.0" + imurmurhash "^0.1.4" + is-glob "^4.0.0" + js-yaml "^4.1.0" + json-stable-stringify-without-jsonify "^1.0.1" + levn "^0.4.1" + lodash.merge "^4.6.2" + minimatch "^3.0.4" + natural-compare "^1.4.0" + optionator "^0.9.1" + regexpp "^3.2.0" + strip-ansi "^6.0.1" + strip-json-comments "^3.1.0" + text-table "^0.2.0" + v8-compile-cache "^2.0.3" + +espree@^5.0.1: + version "5.0.1" + resolved "https://registry.npmjs.org/espree/-/espree-5.0.1.tgz" + integrity sha512-qWAZcWh4XE/RwzLJejfcofscgMc9CamR6Tn1+XRXNzrvUSSbiAjGOI/fggztjIi7y9VLPqnICMIPiGyr8JaZ0A== + dependencies: + acorn "^6.0.7" + acorn-jsx "^5.0.0" + eslint-visitor-keys "^1.0.0" + +espree@^9.3.1: + version "9.3.1" + resolved "https://registry.npmjs.org/espree/-/espree-9.3.1.tgz" + integrity sha512-bvdyLmJMfwkV3NCRl5ZhJf22zBFo1y8bYh3VYb+bfzqNB4Je68P2sSuXyuFquzWLebHpNd2/d5uv7yoP9ISnGQ== + dependencies: + acorn "^8.7.0" + acorn-jsx "^5.3.1" + eslint-visitor-keys "^3.3.0" + +esprima@2.7.x, esprima@^2.7.1: + version "2.7.3" + resolved "https://registry.npmjs.org/esprima/-/esprima-2.7.3.tgz" + integrity sha1-luO3DVd59q1JzQMmc9HDEnZ7pYE= + +esprima@^4.0.0: + version "4.0.1" + resolved "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz" + integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A== + +esquery@^1.0.1, esquery@^1.4.0: + version "1.4.0" + resolved "https://registry.npmjs.org/esquery/-/esquery-1.4.0.tgz" + integrity sha512-cCDispWt5vHHtwMY2YrAQ4ibFkAL8RbH5YGBnZBc90MolvvfkkQcJro/aZiAQUlQ3qgrYS6D6v8Gc5G5CQsc9w== + dependencies: + estraverse "^5.1.0" + +esrecurse@^4.1.0, esrecurse@^4.3.0: + version "4.3.0" + resolved "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz" + integrity sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag== + dependencies: + estraverse "^5.2.0" + +estraverse@^1.9.1: + version "1.9.3" + resolved "https://registry.npmjs.org/estraverse/-/estraverse-1.9.3.tgz" + integrity sha1-r2fy3JIlgkFZUJJgkaQAXSnJu0Q= + +estraverse@^4.1.1: + version "4.3.0" + resolved "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz" + integrity sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw== + +estraverse@^5.1.0, estraverse@^5.2.0: + version "5.3.0" + resolved "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz" + integrity sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA== + +esutils@^2.0.2: + version "2.0.3" + resolved "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz" + integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g== + +etag@~1.8.1: + version "1.8.1" + resolved "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz" + integrity sha1-Qa4u62XvpiJorr/qg6x9eSmbCIc= + +eth-block-tracker@^3.0.0: + version "3.0.1" + resolved "https://registry.npmjs.org/eth-block-tracker/-/eth-block-tracker-3.0.1.tgz" + integrity sha512-WUVxWLuhMmsfenfZvFO5sbl1qFY2IqUlw/FPVmjjdElpqLsZtSG+wPe9Dz7W/sB6e80HgFKknOmKk2eNlznHug== + dependencies: + eth-query "^2.1.0" + ethereumjs-tx "^1.3.3" + ethereumjs-util "^5.1.3" + ethjs-util "^0.1.3" + json-rpc-engine "^3.6.0" + pify "^2.3.0" + tape "^4.6.3" + +eth-ens-namehash@2.0.8, eth-ens-namehash@^2.0.8: + version "2.0.8" + resolved "https://registry.npmjs.org/eth-ens-namehash/-/eth-ens-namehash-2.0.8.tgz" + integrity sha1-IprEbsqG1S4MmR58sq74P/D2i88= + dependencies: + idna-uts46-hx "^2.3.1" + js-sha3 "^0.5.7" + +eth-gas-reporter@^0.2.24: + version "0.2.25" + resolved "https://registry.npmjs.org/eth-gas-reporter/-/eth-gas-reporter-0.2.25.tgz" + integrity sha512-1fRgyE4xUB8SoqLgN3eDfpDfwEfRxh2Sz1b7wzFbyQA+9TekMmvSjjoRu9SKcSVyK+vLkLIsVbJDsTWjw195OQ== + dependencies: + "@ethersproject/abi" "^5.0.0-beta.146" + "@solidity-parser/parser" "^0.14.0" + cli-table3 "^0.5.0" + colors "1.4.0" + ethereum-cryptography "^1.0.3" + ethers "^4.0.40" + fs-readdir-recursive "^1.1.0" + lodash "^4.17.14" + markdown-table "^1.1.3" + mocha "^7.1.1" + req-cwd "^2.0.0" + request "^2.88.0" + request-promise-native "^1.0.5" + sha1 "^1.1.1" + sync-request "^6.0.0" + +eth-json-rpc-infura@^3.1.0: + version "3.2.1" + resolved "https://registry.npmjs.org/eth-json-rpc-infura/-/eth-json-rpc-infura-3.2.1.tgz" + integrity sha512-W7zR4DZvyTn23Bxc0EWsq4XGDdD63+XPUCEhV2zQvQGavDVC4ZpFDK4k99qN7bd7/fjj37+rxmuBOBeIqCA5Mw== + dependencies: + cross-fetch "^2.1.1" + eth-json-rpc-middleware "^1.5.0" + json-rpc-engine "^3.4.0" + json-rpc-error "^2.0.0" + +eth-json-rpc-middleware@^1.5.0: + version "1.6.0" + resolved "https://registry.npmjs.org/eth-json-rpc-middleware/-/eth-json-rpc-middleware-1.6.0.tgz" + integrity sha512-tDVCTlrUvdqHKqivYMjtFZsdD7TtpNLBCfKAcOpaVs7orBMS/A8HWro6dIzNtTZIR05FAbJ3bioFOnZpuCew9Q== + dependencies: + async "^2.5.0" + eth-query "^2.1.2" + eth-tx-summary "^3.1.2" + ethereumjs-block "^1.6.0" + ethereumjs-tx "^1.3.3" + ethereumjs-util "^5.1.2" + ethereumjs-vm "^2.1.0" + fetch-ponyfill "^4.0.0" + json-rpc-engine "^3.6.0" + json-rpc-error "^2.0.0" + json-stable-stringify "^1.0.1" + promise-to-callback "^1.0.0" + tape "^4.6.3" + +eth-lib@0.2.8: + version "0.2.8" + resolved "https://registry.npmjs.org/eth-lib/-/eth-lib-0.2.8.tgz" + integrity sha512-ArJ7x1WcWOlSpzdoTBX8vkwlkSQ85CjjifSZtV4co64vWxSV8geWfPI9x4SVYu3DSxnX4yWFVTtGL+j9DUFLNw== + dependencies: + bn.js "^4.11.6" + elliptic "^6.4.0" + xhr-request-promise "^0.1.2" + +eth-lib@^0.1.26: + version "0.1.29" + resolved "https://registry.npmjs.org/eth-lib/-/eth-lib-0.1.29.tgz" + integrity sha512-bfttrr3/7gG4E02HoWTDUcDDslN003OlOoBxk9virpAZQ1ja/jDgwkWB8QfJF7ojuEowrqy+lzp9VcJG7/k5bQ== + dependencies: + bn.js "^4.11.6" + elliptic "^6.4.0" + nano-json-stream-parser "^0.1.2" + servify "^0.1.12" + ws "^3.0.0" + xhr-request-promise "^0.1.2" + +eth-query@^2.0.2, eth-query@^2.1.0, eth-query@^2.1.2: + version "2.1.2" + resolved "https://registry.npmjs.org/eth-query/-/eth-query-2.1.2.tgz" + integrity sha1-1nQdkAAQa1FRDHLbktY2VFam2l4= + dependencies: + json-rpc-random-id "^1.0.0" + xtend "^4.0.1" + +eth-sig-util@3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/eth-sig-util/-/eth-sig-util-3.0.0.tgz" + integrity sha512-4eFkMOhpGbTxBQ3AMzVf0haUX2uTur7DpWiHzWyTURa28BVJJtOkcb9Ok5TV0YvEPG61DODPW7ZUATbJTslioQ== + dependencies: + buffer "^5.2.1" + elliptic "^6.4.0" + ethereumjs-abi "0.6.5" + ethereumjs-util "^5.1.1" + tweetnacl "^1.0.0" + tweetnacl-util "^0.15.0" + +eth-sig-util@^1.4.2: + version "1.4.2" + resolved "https://registry.yarnpkg.com/eth-sig-util/-/eth-sig-util-1.4.2.tgz#8d958202c7edbaae839707fba6f09ff327606210" + integrity sha1-jZWCAsftuq6Dlwf7pvCf8ydgYhA= + dependencies: + ethereumjs-abi "git+https://github.com/ethereumjs/ethereumjs-abi.git" + ethereumjs-util "^5.1.1" + +eth-tx-summary@^3.1.2: + version "3.2.4" + resolved "https://registry.npmjs.org/eth-tx-summary/-/eth-tx-summary-3.2.4.tgz" + integrity sha512-NtlDnaVZah146Rm8HMRUNMgIwG/ED4jiqk0TME9zFheMl1jOp6jL1m0NKGjJwehXQ6ZKCPr16MTr+qspKpEXNg== + dependencies: + async "^2.1.2" + clone "^2.0.0" + concat-stream "^1.5.1" + end-of-stream "^1.1.0" + eth-query "^2.0.2" + ethereumjs-block "^1.4.1" + ethereumjs-tx "^1.1.1" + ethereumjs-util "^5.0.1" + ethereumjs-vm "^2.6.0" + through2 "^2.0.3" + +ethashjs@~0.0.7: + version "0.0.8" + resolved "https://registry.npmjs.org/ethashjs/-/ethashjs-0.0.8.tgz" + integrity sha512-/MSbf/r2/Ld8o0l15AymjOTlPqpN8Cr4ByUEA9GtR4x0yAh3TdtDzEg29zMjXCNPI7u6E5fOQdj/Cf9Tc7oVNw== + dependencies: + async "^2.1.2" + buffer-xor "^2.0.1" + ethereumjs-util "^7.0.2" + miller-rabin "^4.0.0" + +ethereum-bloom-filters@^1.0.6: + version "1.0.10" + resolved "https://registry.npmjs.org/ethereum-bloom-filters/-/ethereum-bloom-filters-1.0.10.tgz" + integrity sha512-rxJ5OFN3RwjQxDcFP2Z5+Q9ho4eIdEmSc2ht0fCu8Se9nbXjZ7/031uXoUYJ87KHCOdVeiUuwSnoS7hmYAGVHA== + dependencies: + js-sha3 "^0.8.0" + +ethereum-common@0.2.0: + version "0.2.0" + resolved "https://registry.npmjs.org/ethereum-common/-/ethereum-common-0.2.0.tgz" + integrity sha512-XOnAR/3rntJgbCdGhqdaLIxDLWKLmsZOGhHdBKadEr6gEnJLH52k93Ou+TUdFaPN3hJc3isBZBal3U/XZ15abA== + +ethereum-common@^0.0.18: + version "0.0.18" + resolved "https://registry.npmjs.org/ethereum-common/-/ethereum-common-0.0.18.tgz" + integrity sha1-L9w1dvIykDNYl26znaeDIT/5Uj8= + +ethereum-cryptography@^0.1.2, ethereum-cryptography@^0.1.3: + version "0.1.3" + resolved "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz" + integrity sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ== + dependencies: + "@types/pbkdf2" "^3.0.0" + "@types/secp256k1" "^4.0.1" + blakejs "^1.1.0" + browserify-aes "^1.2.0" + bs58check "^2.1.2" + create-hash "^1.2.0" + create-hmac "^1.1.7" + hash.js "^1.1.7" + keccak "^3.0.0" + pbkdf2 "^3.0.17" + randombytes "^2.1.0" + safe-buffer "^5.1.2" + scrypt-js "^3.0.0" + secp256k1 "^4.0.1" + setimmediate "^1.0.5" + +ethereum-cryptography@^1.0.3: + version "1.0.3" + resolved "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-1.0.3.tgz" + integrity sha512-NQLTW0x0CosoVb/n79x/TRHtfvS3hgNUPTUSCu0vM+9k6IIhHFFrAOJReneexjZsoZxMjJHnJn4lrE8EbnSyqQ== + dependencies: + "@noble/hashes" "1.0.0" + "@noble/secp256k1" "1.5.5" + "@scure/bip32" "1.0.1" + "@scure/bip39" "1.0.0" + +ethereum-waffle@^3.4.4: + version "3.4.4" + resolved "https://registry.yarnpkg.com/ethereum-waffle/-/ethereum-waffle-3.4.4.tgz#1378b72040697857b7f5e8f473ca8f97a37b5840" + integrity sha512-PA9+jCjw4WC3Oc5ocSMBj5sXvueWQeAbvCA+hUlb6oFgwwKyq5ka3bWQ7QZcjzIX+TdFkxP4IbFmoY2D8Dkj9Q== + dependencies: + "@ethereum-waffle/chai" "^3.4.4" + "@ethereum-waffle/compiler" "^3.4.4" + "@ethereum-waffle/mock-contract" "^3.4.4" + "@ethereum-waffle/provider" "^3.4.4" + ethers "^5.0.1" + +ethereumjs-abi@0.6.5: + version "0.6.5" + resolved "https://registry.npmjs.org/ethereumjs-abi/-/ethereumjs-abi-0.6.5.tgz" + integrity sha1-WmN+8Wq0NHP6cqKa2QhxQFs/UkE= + dependencies: + bn.js "^4.10.0" + ethereumjs-util "^4.3.0" + +ethereumjs-abi@0.6.8, ethereumjs-abi@^0.6.8: + version "0.6.8" + resolved "https://registry.npmjs.org/ethereumjs-abi/-/ethereumjs-abi-0.6.8.tgz" + integrity sha512-Tx0r/iXI6r+lRsdvkFDlut0N08jWMnKRZ6Gkq+Nmw75lZe4e6o3EkSnkaBP5NF6+m5PTGAr9JP43N3LyeoglsA== + dependencies: + bn.js "^4.11.8" + ethereumjs-util "^6.0.0" + +"ethereumjs-abi@git+https://github.com/ethereumjs/ethereumjs-abi.git": + version "0.6.8" + resolved "git+https://github.com/ethereumjs/ethereumjs-abi.git#ee3994657fa7a427238e6ba92a84d0b529bbcde0" + dependencies: + bn.js "^4.11.8" + ethereumjs-util "^6.0.0" + +ethereumjs-account@3.0.0, ethereumjs-account@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/ethereumjs-account/-/ethereumjs-account-3.0.0.tgz" + integrity sha512-WP6BdscjiiPkQfF9PVfMcwx/rDvfZTjFKY0Uwc09zSQr9JfIVH87dYIJu0gNhBhpmovV4yq295fdllS925fnBA== + dependencies: + ethereumjs-util "^6.0.0" + rlp "^2.2.1" + safe-buffer "^5.1.1" + +ethereumjs-account@^2.0.3: + version "2.0.5" + resolved "https://registry.npmjs.org/ethereumjs-account/-/ethereumjs-account-2.0.5.tgz" + integrity sha512-bgDojnXGjhMwo6eXQC0bY6UK2liSFUSMwwylOmQvZbSl/D7NXQ3+vrGO46ZeOgjGfxXmgIeVNDIiHw7fNZM4VA== + dependencies: + ethereumjs-util "^5.0.0" + rlp "^2.0.0" + safe-buffer "^5.1.1" + +ethereumjs-block@2.2.2, ethereumjs-block@^2.2.2, ethereumjs-block@~2.2.0, ethereumjs-block@~2.2.2: + version "2.2.2" + resolved "https://registry.npmjs.org/ethereumjs-block/-/ethereumjs-block-2.2.2.tgz" + integrity sha512-2p49ifhek3h2zeg/+da6XpdFR3GlqY3BIEiqxGF8j9aSRIgkb7M1Ky+yULBKJOu8PAZxfhsYA+HxUk2aCQp3vg== + dependencies: + async "^2.0.1" + ethereumjs-common "^1.5.0" + ethereumjs-tx "^2.1.1" + ethereumjs-util "^5.0.0" + merkle-patricia-tree "^2.1.2" + +ethereumjs-block@^1.2.2, ethereumjs-block@^1.4.1, ethereumjs-block@^1.6.0: + version "1.7.1" + resolved "https://registry.npmjs.org/ethereumjs-block/-/ethereumjs-block-1.7.1.tgz" + integrity sha512-B+sSdtqm78fmKkBq78/QLKJbu/4Ts4P2KFISdgcuZUPDm9x+N7qgBPIIFUGbaakQh8bzuquiRVbdmvPKqbILRg== + dependencies: + async "^2.0.1" + ethereum-common "0.2.0" + ethereumjs-tx "^1.2.2" + ethereumjs-util "^5.0.0" + merkle-patricia-tree "^2.1.2" + +ethereumjs-blockchain@^4.0.3: + version "4.0.4" + resolved "https://registry.npmjs.org/ethereumjs-blockchain/-/ethereumjs-blockchain-4.0.4.tgz" + integrity sha512-zCxaRMUOzzjvX78DTGiKjA+4h2/sF0OYL1QuPux0DHpyq8XiNoF5GYHtb++GUxVlMsMfZV7AVyzbtgcRdIcEPQ== + dependencies: + async "^2.6.1" + ethashjs "~0.0.7" + ethereumjs-block "~2.2.2" + ethereumjs-common "^1.5.0" + ethereumjs-util "^6.1.0" + flow-stoplight "^1.0.0" + level-mem "^3.0.1" + lru-cache "^5.1.1" + rlp "^2.2.2" + semaphore "^1.1.0" + +ethereumjs-common@1.5.0, ethereumjs-common@^1.1.0, ethereumjs-common@^1.3.2, ethereumjs-common@^1.5.0: + version "1.5.0" + resolved "https://registry.npmjs.org/ethereumjs-common/-/ethereumjs-common-1.5.0.tgz" + integrity sha512-SZOjgK1356hIY7MRj3/ma5qtfr/4B5BL+G4rP/XSMYr2z1H5el4RX5GReYCKmQmYI/nSBmRnwrZ17IfHuG0viQ== + +ethereumjs-tx@2.1.2, ethereumjs-tx@^2.1.1, ethereumjs-tx@^2.1.2: + version "2.1.2" + resolved "https://registry.npmjs.org/ethereumjs-tx/-/ethereumjs-tx-2.1.2.tgz" + integrity sha512-zZEK1onCeiORb0wyCXUvg94Ve5It/K6GD1K+26KfFKodiBiS6d9lfCXlUKGBBdQ+bv7Day+JK0tj1K+BeNFRAw== + dependencies: + ethereumjs-common "^1.5.0" + ethereumjs-util "^6.0.0" + +ethereumjs-tx@^1.1.1, ethereumjs-tx@^1.2.0, ethereumjs-tx@^1.2.2, ethereumjs-tx@^1.3.3: + version "1.3.7" + resolved "https://registry.npmjs.org/ethereumjs-tx/-/ethereumjs-tx-1.3.7.tgz" + integrity sha512-wvLMxzt1RPhAQ9Yi3/HKZTn0FZYpnsmQdbKYfUUpi4j1SEIcbkd9tndVjcPrufY3V7j2IebOpC00Zp2P/Ay2kA== + dependencies: + ethereum-common "^0.0.18" + ethereumjs-util "^5.0.0" + +ethereumjs-util@6.2.1, ethereumjs-util@^6.0.0, ethereumjs-util@^6.1.0, ethereumjs-util@^6.2.0, ethereumjs-util@^6.2.1: + version "6.2.1" + resolved "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-6.2.1.tgz" + integrity sha512-W2Ktez4L01Vexijrm5EB6w7dg4n/TgpoYU4avuT5T3Vmnw/eCRtiBrJfQYS/DCSvDIOLn2k57GcHdeBcgVxAqw== + dependencies: + "@types/bn.js" "^4.11.3" + bn.js "^4.11.0" + create-hash "^1.1.2" + elliptic "^6.5.2" + ethereum-cryptography "^0.1.3" + ethjs-util "0.1.6" + rlp "^2.2.3" + +ethereumjs-util@^4.3.0: + version "4.5.1" + resolved "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-4.5.1.tgz" + integrity sha512-WrckOZ7uBnei4+AKimpuF1B3Fv25OmoRgmYCpGsP7u8PFxXAmAgiJSYT2kRWnt6fVIlKaQlZvuwXp7PIrmn3/w== + dependencies: + bn.js "^4.8.0" + create-hash "^1.1.2" + elliptic "^6.5.2" + ethereum-cryptography "^0.1.3" + rlp "^2.0.0" + +ethereumjs-util@^5.0.0, ethereumjs-util@^5.0.1, ethereumjs-util@^5.1.1, ethereumjs-util@^5.1.2, ethereumjs-util@^5.1.3, ethereumjs-util@^5.1.5, ethereumjs-util@^5.2.0: + version "5.2.1" + resolved "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-5.2.1.tgz" + integrity sha512-v3kT+7zdyCm1HIqWlLNrHGqHGLpGYIhjeHxQjnDXjLT2FyGJDsd3LWMYUo7pAFRrk86CR3nUJfhC81CCoJNNGQ== + dependencies: + bn.js "^4.11.0" + create-hash "^1.1.2" + elliptic "^6.5.2" + ethereum-cryptography "^0.1.3" + ethjs-util "^0.1.3" + rlp "^2.0.0" + safe-buffer "^5.1.1" + +ethereumjs-util@^7.0.10, ethereumjs-util@^7.0.2, ethereumjs-util@^7.1.0, ethereumjs-util@^7.1.1, ethereumjs-util@^7.1.3, ethereumjs-util@^7.1.4: + version "7.1.4" + resolved "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-7.1.4.tgz" + integrity sha512-p6KmuPCX4mZIqsQzXfmSx9Y0l2hqf+VkAiwSisW3UKUFdk8ZkAt+AYaor83z2nSi6CU2zSsXMlD80hAbNEGM0A== + dependencies: + "@types/bn.js" "^5.1.0" + bn.js "^5.1.2" + create-hash "^1.1.2" + ethereum-cryptography "^0.1.3" + rlp "^2.2.4" + +ethereumjs-util@^7.0.3: + version "7.1.5" + resolved "https://registry.yarnpkg.com/ethereumjs-util/-/ethereumjs-util-7.1.5.tgz#9ecf04861e4fbbeed7465ece5f23317ad1129181" + integrity sha512-SDl5kKrQAudFBUe5OJM9Ac6WmMyYmXX/6sTmLZ3ffG2eY6ZIGBes3pEDxNN6V72WyOw4CPD5RomKdsa8DAAwLg== + dependencies: + "@types/bn.js" "^5.1.0" + bn.js "^5.1.2" + create-hash "^1.1.2" + ethereum-cryptography "^0.1.3" + rlp "^2.2.4" + +ethereumjs-vm@4.2.0: + version "4.2.0" + resolved "https://registry.npmjs.org/ethereumjs-vm/-/ethereumjs-vm-4.2.0.tgz" + integrity sha512-X6qqZbsY33p5FTuZqCnQ4+lo957iUJMM6Mpa6bL4UW0dxM6WmDSHuI4j/zOp1E2TDKImBGCJA9QPfc08PaNubA== + dependencies: + async "^2.1.2" + async-eventemitter "^0.2.2" + core-js-pure "^3.0.1" + ethereumjs-account "^3.0.0" + ethereumjs-block "^2.2.2" + ethereumjs-blockchain "^4.0.3" + ethereumjs-common "^1.5.0" + ethereumjs-tx "^2.1.2" + ethereumjs-util "^6.2.0" + fake-merkle-patricia-tree "^1.0.1" + functional-red-black-tree "^1.0.1" + merkle-patricia-tree "^2.3.2" + rustbn.js "~0.2.0" + safe-buffer "^5.1.1" + util.promisify "^1.0.0" + +ethereumjs-vm@^2.1.0, ethereumjs-vm@^2.3.4, ethereumjs-vm@^2.6.0: + version "2.6.0" + resolved "https://registry.npmjs.org/ethereumjs-vm/-/ethereumjs-vm-2.6.0.tgz" + integrity sha512-r/XIUik/ynGbxS3y+mvGnbOKnuLo40V5Mj1J25+HEO63aWYREIqvWeRO/hnROlMBE5WoniQmPmhiaN0ctiHaXw== + dependencies: + async "^2.1.2" + async-eventemitter "^0.2.2" + ethereumjs-account "^2.0.3" + ethereumjs-block "~2.2.0" + ethereumjs-common "^1.1.0" + ethereumjs-util "^6.0.0" + fake-merkle-patricia-tree "^1.0.1" + functional-red-black-tree "^1.0.1" + merkle-patricia-tree "^2.3.2" + rustbn.js "~0.2.0" + safe-buffer "^5.1.1" + +ethereumjs-wallet@0.6.5: + version "0.6.5" + resolved "https://registry.npmjs.org/ethereumjs-wallet/-/ethereumjs-wallet-0.6.5.tgz" + integrity sha512-MDwjwB9VQVnpp/Dc1XzA6J1a3wgHQ4hSvA1uWNatdpOrtCbPVuQSKSyRnjLvS0a+KKMw2pvQ9Ybqpb3+eW8oNA== + dependencies: + aes-js "^3.1.1" + bs58check "^2.1.2" + ethereum-cryptography "^0.1.3" + ethereumjs-util "^6.0.0" + randombytes "^2.0.6" + safe-buffer "^5.1.2" + scryptsy "^1.2.1" + utf8 "^3.0.0" + uuid "^3.3.2" + +ethers-eip712@^0.2.0: + version "0.2.0" + resolved "https://registry.npmjs.org/ethers-eip712/-/ethers-eip712-0.2.0.tgz" + integrity sha512-fgS196gCIXeiLwhsWycJJuxI9nL/AoUPGSQ+yvd+8wdWR+43G+J1n69LmWVWvAON0M6qNaf2BF4/M159U8fujQ== + +ethers@^4.0.32, ethers@^4.0.40: + version "4.0.49" + resolved "https://registry.npmjs.org/ethers/-/ethers-4.0.49.tgz" + integrity sha512-kPltTvWiyu+OktYy1IStSO16i2e7cS9D9OxZ81q2UUaiNPVrm/RTcbxamCXF9VUSKzJIdJV68EAIhTEVBalRWg== + dependencies: + aes-js "3.0.0" + bn.js "^4.11.9" + elliptic "6.5.4" + hash.js "1.1.3" + js-sha3 "0.5.7" + scrypt-js "2.0.4" + setimmediate "1.0.4" + uuid "2.0.1" + xmlhttprequest "1.8.0" + +ethers@^5.0.1, ethers@^5.0.2, ethers@^5.5.2, ethers@^5.5.3: + version "5.6.4" + resolved "https://registry.npmjs.org/ethers/-/ethers-5.6.4.tgz" + integrity sha512-62UIfxAQXdf67TeeOaoOoPctm5hUlYgfd0iW3wxfj7qRYKDcvvy0f+sJ3W2/Pyx77R8dblvejA8jokj+lS+ATQ== + dependencies: + "@ethersproject/abi" "5.6.1" + "@ethersproject/abstract-provider" "5.6.0" + "@ethersproject/abstract-signer" "5.6.0" + "@ethersproject/address" "5.6.0" + "@ethersproject/base64" "5.6.0" + "@ethersproject/basex" "5.6.0" + "@ethersproject/bignumber" "5.6.0" + "@ethersproject/bytes" "5.6.1" + "@ethersproject/constants" "5.6.0" + "@ethersproject/contracts" "5.6.0" + "@ethersproject/hash" "5.6.0" + "@ethersproject/hdnode" "5.6.0" + "@ethersproject/json-wallets" "5.6.0" + "@ethersproject/keccak256" "5.6.0" + "@ethersproject/logger" "5.6.0" + "@ethersproject/networks" "5.6.2" + "@ethersproject/pbkdf2" "5.6.0" + "@ethersproject/properties" "5.6.0" + "@ethersproject/providers" "5.6.4" + "@ethersproject/random" "5.6.0" + "@ethersproject/rlp" "5.6.0" + "@ethersproject/sha2" "5.6.0" + "@ethersproject/signing-key" "5.6.0" + "@ethersproject/solidity" "5.6.0" + "@ethersproject/strings" "5.6.0" + "@ethersproject/transactions" "5.6.0" + "@ethersproject/units" "5.6.0" + "@ethersproject/wallet" "5.6.0" + "@ethersproject/web" "5.6.0" + "@ethersproject/wordlists" "5.6.0" + +ethers@^5.6.8: + version "5.6.8" + resolved "https://registry.yarnpkg.com/ethers/-/ethers-5.6.8.tgz#d36b816b4896341a80a8bbd2a44e8cb6e9b98dd4" + integrity sha512-YxIGaltAOdvBFPZwIkyHnXbW40f1r8mHUgapW6dxkO+6t7H6wY8POUn0Kbxrd/N7I4hHxyi7YCddMAH/wmho2w== + dependencies: + "@ethersproject/abi" "5.6.3" + "@ethersproject/abstract-provider" "5.6.1" + "@ethersproject/abstract-signer" "5.6.2" + "@ethersproject/address" "5.6.1" + "@ethersproject/base64" "5.6.1" + "@ethersproject/basex" "5.6.1" + "@ethersproject/bignumber" "5.6.2" + "@ethersproject/bytes" "5.6.1" + "@ethersproject/constants" "5.6.1" + "@ethersproject/contracts" "5.6.2" + "@ethersproject/hash" "5.6.1" + "@ethersproject/hdnode" "5.6.2" + "@ethersproject/json-wallets" "5.6.1" + "@ethersproject/keccak256" "5.6.1" + "@ethersproject/logger" "5.6.0" + "@ethersproject/networks" "5.6.3" + "@ethersproject/pbkdf2" "5.6.1" + "@ethersproject/properties" "5.6.0" + "@ethersproject/providers" "5.6.8" + "@ethersproject/random" "5.6.1" + "@ethersproject/rlp" "5.6.1" + "@ethersproject/sha2" "5.6.1" + "@ethersproject/signing-key" "5.6.2" + "@ethersproject/solidity" "5.6.1" + "@ethersproject/strings" "5.6.1" + "@ethersproject/transactions" "5.6.2" + "@ethersproject/units" "5.6.1" + "@ethersproject/wallet" "5.6.2" + "@ethersproject/web" "5.6.1" + "@ethersproject/wordlists" "5.6.1" + +ethjs-unit@0.1.6: + version "0.1.6" + resolved "https://registry.npmjs.org/ethjs-unit/-/ethjs-unit-0.1.6.tgz" + integrity sha1-xmWSHkduh7ziqdWIpv4EBbLEFpk= + dependencies: + bn.js "4.11.6" + number-to-bn "1.7.0" + +ethjs-util@0.1.6, ethjs-util@^0.1.3, ethjs-util@^0.1.6: + version "0.1.6" + resolved "https://registry.npmjs.org/ethjs-util/-/ethjs-util-0.1.6.tgz" + integrity sha512-CUnVOQq7gSpDHZVVrQW8ExxUETWrnrvXYvYz55wOU8Uj4VCgw56XC2B/fVqQN+f7gmrnRHSLVnFAwsCuNwji8w== + dependencies: + is-hex-prefixed "1.0.0" + strip-hex-prefix "1.0.0" + +event-target-shim@^5.0.0: + version "5.0.1" + resolved "https://registry.npmjs.org/event-target-shim/-/event-target-shim-5.0.1.tgz" + integrity sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ== + +eventemitter3@4.0.4: + version "4.0.4" + resolved "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.4.tgz" + integrity sha512-rlaVLnVxtxvoyLsQQFBx53YmXHDxRIzzTLbdfxqi4yocpSjAxXwkU0cScM5JgSKMqEhrZpnvQ2D9gjylR0AimQ== + +events@^3.0.0: + version "3.3.0" + resolved "https://registry.yarnpkg.com/events/-/events-3.3.0.tgz#31a95ad0a924e2d2c419a813aeb2c4e878ea7400" + integrity sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q== + +evp_bytestokey@^1.0.0, evp_bytestokey@^1.0.3: + version "1.0.3" + resolved "https://registry.npmjs.org/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz" + integrity sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA== + dependencies: + md5.js "^1.3.4" + safe-buffer "^5.1.1" + +execa@^5.1.1: + version "5.1.1" + resolved "https://registry.npmjs.org/execa/-/execa-5.1.1.tgz" + integrity sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg== + dependencies: + cross-spawn "^7.0.3" + get-stream "^6.0.0" + human-signals "^2.1.0" + is-stream "^2.0.0" + merge-stream "^2.0.0" + npm-run-path "^4.0.1" + onetime "^5.1.2" + signal-exit "^3.0.3" + strip-final-newline "^2.0.0" + +expand-brackets@^2.1.4: + version "2.1.4" + resolved "https://registry.npmjs.org/expand-brackets/-/expand-brackets-2.1.4.tgz" + integrity sha1-t3c14xXOMPa27/D4OwQVGiJEliI= + dependencies: + debug "^2.3.3" + define-property "^0.2.5" + extend-shallow "^2.0.1" + posix-character-classes "^0.1.0" + regex-not "^1.0.0" + snapdragon "^0.8.1" + to-regex "^3.0.1" + +express@^4.14.0: + version "4.18.0" + resolved "https://registry.npmjs.org/express/-/express-4.18.0.tgz" + integrity sha512-EJEXxiTQJS3lIPrU1AE2vRuT7X7E+0KBbpm5GSoK524yl0K8X+er8zS2P14E64eqsVNoWbMCT7MpmQ+ErAhgRg== + dependencies: + accepts "~1.3.8" + array-flatten "1.1.1" + body-parser "1.20.0" + content-disposition "0.5.4" + content-type "~1.0.4" + cookie "0.5.0" + cookie-signature "1.0.6" + debug "2.6.9" + depd "2.0.0" + encodeurl "~1.0.2" + escape-html "~1.0.3" + etag "~1.8.1" + finalhandler "1.2.0" + fresh "0.5.2" + http-errors "2.0.0" + merge-descriptors "1.0.1" + methods "~1.1.2" + on-finished "2.4.1" + parseurl "~1.3.3" + path-to-regexp "0.1.7" + proxy-addr "~2.0.7" + qs "6.10.3" + range-parser "~1.2.1" + safe-buffer "5.2.1" + send "0.18.0" + serve-static "1.15.0" + setprototypeof "1.2.0" + statuses "2.0.1" + type-is "~1.6.18" + utils-merge "1.0.1" + vary "~1.1.2" + +ext@^1.1.2: + version "1.6.0" + resolved "https://registry.npmjs.org/ext/-/ext-1.6.0.tgz" + integrity sha512-sdBImtzkq2HpkdRLtlLWDa6w4DX22ijZLKx8BMPUuKe1c5lbN6xwQDQCxSfxBQnHZ13ls/FH0MQZx/q/gr6FQg== + dependencies: + type "^2.5.0" + +extend-shallow@^2.0.1: + version "2.0.1" + resolved "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz" + integrity sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8= + dependencies: + is-extendable "^0.1.0" + +extend-shallow@^3.0.0, extend-shallow@^3.0.2: + version "3.0.2" + resolved "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz" + integrity sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg= + dependencies: + assign-symbols "^1.0.0" + is-extendable "^1.0.1" + +extend@~3.0.2: + version "3.0.2" + resolved "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz" + integrity sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g== + +external-editor@^3.0.3: + version "3.1.0" + resolved "https://registry.npmjs.org/external-editor/-/external-editor-3.1.0.tgz" + integrity sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew== + dependencies: + chardet "^0.7.0" + iconv-lite "^0.4.24" + tmp "^0.0.33" + +extglob@^2.0.4: + version "2.0.4" + resolved "https://registry.npmjs.org/extglob/-/extglob-2.0.4.tgz" + integrity sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw== + dependencies: + array-unique "^0.3.2" + define-property "^1.0.0" + expand-brackets "^2.1.4" + extend-shallow "^2.0.1" + fragment-cache "^0.2.1" + regex-not "^1.0.0" + snapdragon "^0.8.1" + to-regex "^3.0.1" + +extsprintf@1.3.0, extsprintf@^1.2.0: + version "1.3.0" + resolved "https://registry.npmjs.org/extsprintf/-/extsprintf-1.3.0.tgz" + integrity sha1-lpGEQOMEGnpBT4xS48V06zw+HgU= + +fake-merkle-patricia-tree@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/fake-merkle-patricia-tree/-/fake-merkle-patricia-tree-1.0.1.tgz" + integrity sha1-S4w6z7Ugr635hgsfFM2M40As3dM= + dependencies: + checkpoint-store "^1.1.0" + +fast-deep-equal@^3.1.1, fast-deep-equal@^3.1.3: + version "3.1.3" + resolved "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz" + integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q== + +fast-diff@^1.1.2: + version "1.2.0" + resolved "https://registry.npmjs.org/fast-diff/-/fast-diff-1.2.0.tgz" + integrity sha512-xJuoT5+L99XlZ8twedaRf6Ax2TgQVxvgZOYoPKqZufmJib0tL2tegPBOZb1pVNgIhlqDlA0eO0c3wBvQcmzx4w== + +fast-glob@^3.0.3, fast-glob@^3.2.9: + version "3.2.11" + resolved "https://registry.npmjs.org/fast-glob/-/fast-glob-3.2.11.tgz" + integrity sha512-xrO3+1bxSo3ZVHAnqzyuewYT6aMFHRAd4Kcs92MAonjwQZLsK9d0SF1IyQ3k5PoirxTW0Oe/RqFgMQ6TcNE5Ew== + dependencies: + "@nodelib/fs.stat" "^2.0.2" + "@nodelib/fs.walk" "^1.2.3" + glob-parent "^5.1.2" + merge2 "^1.3.0" + micromatch "^4.0.4" + +fast-json-stable-stringify@^2.0.0: + version "2.1.0" + resolved "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz" + integrity sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw== + +fast-levenshtein@^2.0.6, fast-levenshtein@~2.0.6: + version "2.0.6" + resolved "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz" + integrity sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc= + +fastq@^1.6.0: + version "1.13.0" + resolved "https://registry.npmjs.org/fastq/-/fastq-1.13.0.tgz" + integrity sha512-YpkpUnK8od0o1hmeSc7UUs/eB/vIPWJYjKck2QKIzAf71Vm1AAQ3EbuZB3g2JIy+pg+ERD0vqI79KyZiB2e2Nw== + dependencies: + reusify "^1.0.4" + +fetch-blob@^3.1.2, fetch-blob@^3.1.4: + version "3.1.5" + resolved "https://registry.npmjs.org/fetch-blob/-/fetch-blob-3.1.5.tgz" + integrity sha512-N64ZpKqoLejlrwkIAnb9iLSA3Vx/kjgzpcDhygcqJ2KKjky8nCgUQ+dzXtbrLaWZGZNmNfQTsiQ0weZ1svglHg== + dependencies: + node-domexception "^1.0.0" + web-streams-polyfill "^3.0.3" + +fetch-ponyfill@^4.0.0: + version "4.1.0" + resolved "https://registry.npmjs.org/fetch-ponyfill/-/fetch-ponyfill-4.1.0.tgz" + integrity sha1-rjzl9zLGReq4fkroeTQUcJsjmJM= + dependencies: + node-fetch "~1.7.1" + +figures@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/figures/-/figures-2.0.0.tgz" + integrity sha1-OrGi0qYsi/tDGgyUy3l6L84nyWI= + dependencies: + escape-string-regexp "^1.0.5" + +file-entry-cache@^5.0.1: + version "5.0.1" + resolved "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-5.0.1.tgz" + integrity sha512-bCg29ictuBaKUwwArK4ouCaqDgLZcysCFLmM/Yn/FDoqndh/9vNuQfXRDvTuXKLxfD/JtZQGKFT8MGcJBK644g== + dependencies: + flat-cache "^2.0.1" + +file-entry-cache@^6.0.1: + version "6.0.1" + resolved "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz" + integrity sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg== + dependencies: + flat-cache "^3.0.4" + +fill-range@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/fill-range/-/fill-range-4.0.0.tgz" + integrity sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc= + dependencies: + extend-shallow "^2.0.1" + is-number "^3.0.0" + repeat-string "^1.6.1" + to-regex-range "^2.1.0" + +fill-range@^7.0.1: + version "7.0.1" + resolved "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz" + integrity sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ== + dependencies: + to-regex-range "^5.0.1" + +finalhandler@1.2.0: + version "1.2.0" + resolved "https://registry.npmjs.org/finalhandler/-/finalhandler-1.2.0.tgz" + integrity sha512-5uXcUVftlQMFnWC9qu/svkWv3GTd2PfUhK/3PLkYNAe7FbqJMt3515HaxE6eRL74GdsriiwujiawdaB1BpEISg== + dependencies: + debug "2.6.9" + encodeurl "~1.0.2" + escape-html "~1.0.3" + on-finished "2.4.1" + parseurl "~1.3.3" + statuses "2.0.1" + unpipe "~1.0.0" + +find-replace@^1.0.3: + version "1.0.3" + resolved "https://registry.npmjs.org/find-replace/-/find-replace-1.0.3.tgz" + integrity sha1-uI5zZNLZyVlVnziMZmcNYTBEH6A= + dependencies: + array-back "^1.0.4" + test-value "^2.1.0" + +find-replace@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/find-replace/-/find-replace-3.0.0.tgz" + integrity sha512-6Tb2myMioCAgv5kfvP5/PkZZ/ntTpVK39fHY7WkWBgvbeE+VHd/tZuZ4mrC+bxh4cfOZeYKVPaJIZtZXV7GNCQ== + dependencies: + array-back "^3.0.1" + +find-up@3.0.0, find-up@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/find-up/-/find-up-3.0.0.tgz" + integrity sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg== + dependencies: + locate-path "^3.0.0" + +find-up@5.0.0: + version "5.0.0" + resolved "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz" + integrity sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng== + dependencies: + locate-path "^6.0.0" + path-exists "^4.0.0" + +find-up@^1.0.0: + version "1.1.2" + resolved "https://registry.npmjs.org/find-up/-/find-up-1.1.2.tgz" + integrity sha1-ay6YIrGizgpgq2TWEOzK1TyyTQ8= + dependencies: + path-exists "^2.0.0" + pinkie-promise "^2.0.0" + +find-up@^2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/find-up/-/find-up-2.1.0.tgz" + integrity sha1-RdG35QbHF93UgndaK3eSCjwMV6c= + dependencies: + locate-path "^2.0.0" + +find-yarn-workspace-root@^1.2.1: + version "1.2.1" + resolved "https://registry.npmjs.org/find-yarn-workspace-root/-/find-yarn-workspace-root-1.2.1.tgz" + integrity sha512-dVtfb0WuQG+8Ag2uWkbG79hOUzEsRrhBzgfn86g2sJPkzmcpGdghbNTfUKGTxymFrY/tLIodDzLoW9nOJ4FY8Q== + dependencies: + fs-extra "^4.0.3" + micromatch "^3.1.4" + +find-yarn-workspace-root@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/find-yarn-workspace-root/-/find-yarn-workspace-root-2.0.0.tgz" + integrity sha512-1IMnbjt4KzsQfnhnzNd8wUEgXZ44IzZaZmnLYx7D5FZlaHt2gW20Cri8Q+E/t5tIj4+epTBub+2Zxu/vNILzqQ== + dependencies: + micromatch "^4.0.2" + +flat-cache@^2.0.1: + version "2.0.1" + resolved "https://registry.npmjs.org/flat-cache/-/flat-cache-2.0.1.tgz" + integrity sha512-LoQe6yDuUMDzQAEH8sgmh4Md6oZnc/7PjtwjNFSzveXqSHt6ka9fPBuso7IGf9Rz4uqnSnWiFH2B/zj24a5ReA== + dependencies: + flatted "^2.0.0" + rimraf "2.6.3" + write "1.0.3" + +flat-cache@^3.0.4: + version "3.0.4" + resolved "https://registry.npmjs.org/flat-cache/-/flat-cache-3.0.4.tgz" + integrity sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg== + dependencies: + flatted "^3.1.0" + rimraf "^3.0.2" + +flat@^4.1.0: + version "4.1.1" + resolved "https://registry.npmjs.org/flat/-/flat-4.1.1.tgz" + integrity sha512-FmTtBsHskrU6FJ2VxCnsDb84wu9zhmO3cUX2kGFb5tuwhfXxGciiT0oRY+cck35QmG+NmGh5eLz6lLCpWTqwpA== + dependencies: + is-buffer "~2.0.3" + +flat@^5.0.2: + version "5.0.2" + resolved "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz" + integrity sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ== + +flatted@^2.0.0: + version "2.0.2" + resolved "https://registry.npmjs.org/flatted/-/flatted-2.0.2.tgz" + integrity sha512-r5wGx7YeOwNWNlCA0wQ86zKyDLMQr+/RB8xy74M4hTphfmjlijTSSXGuH8rnvKZnfT9i+75zmd8jcKdMR4O6jA== + +flatted@^3.1.0: + version "3.2.5" + resolved "https://registry.npmjs.org/flatted/-/flatted-3.2.5.tgz" + integrity sha512-WIWGi2L3DyTUvUrwRKgGi9TwxQMUEqPOPQBVi71R96jZXJdFskXEmf54BoZaS1kknGODoIGASGEzBUYdyMCBJg== + +flow-stoplight@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/flow-stoplight/-/flow-stoplight-1.0.0.tgz" + integrity sha1-SiksW8/4s5+mzAyxqFPYbyfu/3s= + +fmix@^0.1.0: + version "0.1.0" + resolved "https://registry.yarnpkg.com/fmix/-/fmix-0.1.0.tgz#c7bbf124dec42c9d191cfb947d0a9778dd986c0c" + integrity sha512-Y6hyofImk9JdzU8k5INtTXX1cu8LDlePWDFU5sftm9H+zKCr5SGrVjdhkvsim646cw5zD0nADj8oHyXMZmCZ9w== + dependencies: + imul "^1.0.0" + +follow-redirects@^1.12.1: + version "1.14.9" + resolved "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.14.9.tgz" + integrity sha512-MQDfihBQYMcyy5dhRDJUHcw7lb2Pv/TuE6xP1vyraLukNDHKbDxDNaOE3NbCAdKQApno+GPRyo1YAp89yCjK4w== + +follow-redirects@^1.14.0: + version "1.15.1" + resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.15.1.tgz#0ca6a452306c9b276e4d3127483e29575e207ad5" + integrity sha512-yLAMQs+k0b2m7cVxpS1VKJVvoz7SS9Td1zss3XRwXj+ZDH00RJgnuLx7E44wx02kQLrdM3aOOy+FpzS7+8OizA== + +for-each@^0.3.3, for-each@~0.3.3: + version "0.3.3" + resolved "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz" + integrity sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw== + dependencies: + is-callable "^1.1.3" + +for-in@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/for-in/-/for-in-1.0.2.tgz" + integrity sha1-gQaNKVqBQuwKxybG4iAMMPttXoA= + +foreach@^2.0.5: + version "2.0.5" + resolved "https://registry.npmjs.org/foreach/-/foreach-2.0.5.tgz" + integrity sha1-C+4AUBiusmDQo6865ljdATbsG5k= + +forever-agent@~0.6.1: + version "0.6.1" + resolved "https://registry.npmjs.org/forever-agent/-/forever-agent-0.6.1.tgz" + integrity sha1-+8cfDEGt6zf5bFd60e1C2P2sypE= + +form-data@^2.2.0: + version "2.5.1" + resolved "https://registry.npmjs.org/form-data/-/form-data-2.5.1.tgz" + integrity sha512-m21N3WOmEEURgk6B9GLOE4RuWOFf28Lhh9qGYeNlGq4VDXUlJy2th2slBNU8Gp8EzloYZOibZJ7t5ecIrFSjVA== + dependencies: + asynckit "^0.4.0" + combined-stream "^1.0.6" + mime-types "^2.1.12" + +form-data@^3.0.0: + version "3.0.1" + resolved "https://registry.npmjs.org/form-data/-/form-data-3.0.1.tgz" + integrity sha512-RHkBKtLWUVwd7SqRIvCZMEvAMoGUp0XU+seQiZejj0COz3RI3hWP4sCv3gZWWLjJTd7rGwcsF5eKZGii0r/hbg== + dependencies: + asynckit "^0.4.0" + combined-stream "^1.0.8" + mime-types "^2.1.12" + +form-data@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/form-data/-/form-data-4.0.0.tgz#93919daeaf361ee529584b9b31664dc12c9fa452" + integrity sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww== + dependencies: + asynckit "^0.4.0" + combined-stream "^1.0.8" + mime-types "^2.1.12" + +form-data@~2.3.2: + version "2.3.3" + resolved "https://registry.npmjs.org/form-data/-/form-data-2.3.3.tgz" + integrity sha512-1lLKB2Mu3aGP1Q/2eCOx0fNbRMe7XdwktwOruhfqqd0rIJWwN4Dh+E3hrPSlDCXnSR7UtZ1N38rVXm+6+MEhJQ== + dependencies: + asynckit "^0.4.0" + combined-stream "^1.0.6" + mime-types "^2.1.12" + +formdata-polyfill@^4.0.10: + version "4.0.10" + resolved "https://registry.npmjs.org/formdata-polyfill/-/formdata-polyfill-4.0.10.tgz" + integrity sha512-buewHzMvYL29jdeQTVILecSaZKnt/RJWjoZCF5OW60Z67/GmSLBkOFM7qh1PI3zFNtJbaZL5eQu1vLfazOwj4g== + dependencies: + fetch-blob "^3.1.2" + +forwarded@0.2.0: + version "0.2.0" + resolved "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz" + integrity sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow== + +fp-ts@1.19.3: + version "1.19.3" + resolved "https://registry.npmjs.org/fp-ts/-/fp-ts-1.19.3.tgz" + integrity sha512-H5KQDspykdHuztLTg+ajGN0Z2qUjcEf3Ybxc6hLt0k7/zPkn29XnKnxlBPyW2XIddWrGaJBzBl4VLYOtk39yZg== + +fp-ts@^1.0.0: + version "1.19.5" + resolved "https://registry.npmjs.org/fp-ts/-/fp-ts-1.19.5.tgz" + integrity sha512-wDNqTimnzs8QqpldiId9OavWK2NptormjXnRJTQecNjzwfyp6P/8s/zG8e4h3ja3oqkKaY72UlTjQYt/1yXf9A== + +fragment-cache@^0.2.1: + version "0.2.1" + resolved "https://registry.npmjs.org/fragment-cache/-/fragment-cache-0.2.1.tgz" + integrity sha1-QpD60n8T6Jvn8zeZxrxaCr//DRk= + dependencies: + map-cache "^0.2.2" + +fresh@0.5.2: + version "0.5.2" + resolved "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz" + integrity sha1-PYyt2Q2XZWn6g1qx+OSyOhBWBac= + +fs-extra@^0.30.0: + version "0.30.0" + resolved "https://registry.npmjs.org/fs-extra/-/fs-extra-0.30.0.tgz" + integrity sha1-8jP/zAjU2n1DLapEl3aYnbHfk/A= + dependencies: + graceful-fs "^4.1.2" + jsonfile "^2.1.0" + klaw "^1.0.0" + path-is-absolute "^1.0.0" + rimraf "^2.2.8" + +fs-extra@^10.0.0: + version "10.1.0" + resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-10.1.0.tgz#02873cfbc4084dde127eaa5f9905eef2325d1abf" + integrity sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ== + dependencies: + graceful-fs "^4.2.0" + jsonfile "^6.0.1" + universalify "^2.0.0" + +fs-extra@^4.0.2, fs-extra@^4.0.3: + version "4.0.3" + resolved "https://registry.npmjs.org/fs-extra/-/fs-extra-4.0.3.tgz" + integrity sha512-q6rbdDd1o2mAnQreO7YADIxf/Whx4AHBiRf6d+/cVT8h44ss+lHgxf1FemcqDnQt9X3ct4McHr+JMGlYSsK7Cg== + dependencies: + graceful-fs "^4.1.2" + jsonfile "^4.0.0" + universalify "^0.1.0" + +fs-extra@^7.0.0, fs-extra@^7.0.1: + version "7.0.1" + resolved "https://registry.npmjs.org/fs-extra/-/fs-extra-7.0.1.tgz" + integrity sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw== + dependencies: + graceful-fs "^4.1.2" + jsonfile "^4.0.0" + universalify "^0.1.0" + +fs-extra@^8.1.0: + version "8.1.0" + resolved "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz" + integrity sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g== + dependencies: + graceful-fs "^4.2.0" + jsonfile "^4.0.0" + universalify "^0.1.0" + +fs-extra@^9.0.1, fs-extra@^9.1.0: + version "9.1.0" + resolved "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz" + integrity sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ== + dependencies: + at-least-node "^1.0.0" + graceful-fs "^4.2.0" + jsonfile "^6.0.1" + universalify "^2.0.0" + +fs-minipass@^1.2.7: + version "1.2.7" + resolved "https://registry.npmjs.org/fs-minipass/-/fs-minipass-1.2.7.tgz" + integrity sha512-GWSSJGFy4e9GUeCcbIkED+bgAoFyj7XF1mV8rma3QW4NIqX9Kyx79N/PF61H5udOV3aY1IaMLs6pGbH71nlCTA== + dependencies: + minipass "^2.6.0" + +fs-readdir-recursive@^1.1.0: + version "1.1.0" + resolved "https://registry.npmjs.org/fs-readdir-recursive/-/fs-readdir-recursive-1.1.0.tgz" + integrity sha512-GNanXlVr2pf02+sPN40XN8HG+ePaNcvM0q5mZBd668Obwb0yD5GiUbZOFgwn8kGMY6I3mdyDJzieUy3PTYyTRA== + +fs.realpath@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz" + integrity sha1-FQStJSMVjKpA20onh8sBQRmU6k8= + +fsevents@~2.1.1: + version "2.1.3" + resolved "https://registry.npmjs.org/fsevents/-/fsevents-2.1.3.tgz" + integrity sha512-Auw9a4AxqWpa9GUfj370BMPzzyncfBABW8Mab7BGWBYDj4Isgq+cDKtx0i6u9jcX9pQDnswsaaOTgTmA5pEjuQ== + +fsevents@~2.3.2: + version "2.3.2" + resolved "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz" + integrity sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA== + +function-bind@^1.1.1: + version "1.1.1" + resolved "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz" + integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A== + +function.prototype.name@^1.1.5: + version "1.1.5" + resolved "https://registry.yarnpkg.com/function.prototype.name/-/function.prototype.name-1.1.5.tgz#cce0505fe1ffb80503e6f9e46cc64e46a12a9621" + integrity sha512-uN7m/BzVKQnCUF/iW8jYea67v++2u7m5UgENbHRtdDVclOUP+FMPlCNdmk0h/ysGyo2tavMJEDqJAkJdRa1vMA== + dependencies: + call-bind "^1.0.2" + define-properties "^1.1.3" + es-abstract "^1.19.0" + functions-have-names "^1.2.2" + +functional-red-black-tree@^1.0.1, functional-red-black-tree@~1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz" + integrity sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc= + +functions-have-names@^1.2.2: + version "1.2.3" + resolved "https://registry.yarnpkg.com/functions-have-names/-/functions-have-names-1.2.3.tgz#0404fe4ee2ba2f607f0e0ec3c80bae994133b834" + integrity sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ== + +ganache-core@^2.13.2: + version "2.13.2" + resolved "https://registry.npmjs.org/ganache-core/-/ganache-core-2.13.2.tgz" + integrity sha512-tIF5cR+ANQz0+3pHWxHjIwHqFXcVo0Mb+kcsNhglNFALcYo49aQpnS9dqHartqPfMFjiHh/qFoD3mYK0d/qGgw== + dependencies: + abstract-leveldown "3.0.0" + async "2.6.2" + bip39 "2.5.0" + cachedown "1.0.0" + clone "2.1.2" + debug "3.2.6" + encoding-down "5.0.4" + eth-sig-util "3.0.0" + ethereumjs-abi "0.6.8" + ethereumjs-account "3.0.0" + ethereumjs-block "2.2.2" + ethereumjs-common "1.5.0" + ethereumjs-tx "2.1.2" + ethereumjs-util "6.2.1" + ethereumjs-vm "4.2.0" + heap "0.2.6" + keccak "3.0.1" + level-sublevel "6.6.4" + levelup "3.1.1" + lodash "4.17.20" + lru-cache "5.1.1" + merkle-patricia-tree "3.0.0" + patch-package "6.2.2" + seedrandom "3.0.1" + source-map-support "0.5.12" + tmp "0.1.0" + web3-provider-engine "14.2.1" + websocket "1.0.32" + optionalDependencies: + ethereumjs-wallet "0.6.5" + web3 "1.2.11" + +get-caller-file@^1.0.1: + version "1.0.3" + resolved "https://registry.npmjs.org/get-caller-file/-/get-caller-file-1.0.3.tgz" + integrity sha512-3t6rVToeoZfYSGd8YoLFR2DJkiQrIiUrGcjvFX2mDw3bn6k2OtwHN0TNCLbBO+w8qTvimhDkv+LSscbJY1vE6w== + +get-caller-file@^2.0.1, get-caller-file@^2.0.5: + version "2.0.5" + resolved "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz" + integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg== + +get-func-name@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/get-func-name/-/get-func-name-2.0.0.tgz" + integrity sha1-6td0q+5y4gQJQzoGY2YCPdaIekE= + +get-intrinsic@^1.0.2, get-intrinsic@^1.1.0, get-intrinsic@^1.1.1: + version "1.1.1" + resolved "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.1.1.tgz" + integrity sha512-kWZrnVM42QCiEA2Ig1bG8zjoIMOgxWwYCEeNdwY6Tv/cOSeGpcoX4pXHfKUxNKVoArnrEr2e9srnAxxGIraS9Q== + dependencies: + function-bind "^1.1.1" + has "^1.0.3" + has-symbols "^1.0.1" + +get-port@^3.1.0: + version "3.2.0" + resolved "https://registry.npmjs.org/get-port/-/get-port-3.2.0.tgz" + integrity sha1-3Xzn3hh8Bsi/NTeWrHHgmfCYDrw= + +get-stream@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/get-stream/-/get-stream-3.0.0.tgz" + integrity sha1-jpQ9E1jcN1VQVOy+LtsFqhdO3hQ= + +get-stream@^4.1.0: + version "4.1.0" + resolved "https://registry.npmjs.org/get-stream/-/get-stream-4.1.0.tgz" + integrity sha512-GMat4EJ5161kIy2HevLlr4luNjBgvmj413KaQA7jt4V8B4RDsfpHk7WQ9GVqfYyyx8OS/L66Kox+rJRNklLK7w== + dependencies: + pump "^3.0.0" + +get-stream@^5.1.0: + version "5.2.0" + resolved "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz" + integrity sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA== + dependencies: + pump "^3.0.0" + +get-stream@^6.0.0: + version "6.0.1" + resolved "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz" + integrity sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg== + +get-symbol-description@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.0.0.tgz" + integrity sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw== + dependencies: + call-bind "^1.0.2" + get-intrinsic "^1.1.1" + +get-value@^2.0.3, get-value@^2.0.6: + version "2.0.6" + resolved "https://registry.npmjs.org/get-value/-/get-value-2.0.6.tgz" + integrity sha1-3BXKHGcjh8p2vTesCjlbogQqLCg= + +getpass@^0.1.1: + version "0.1.7" + resolved "https://registry.npmjs.org/getpass/-/getpass-0.1.7.tgz" + integrity sha1-Xv+OPmhNVprkyysSgmBOi6YhSfo= + dependencies: + assert-plus "^1.0.0" + +ghost-testrpc@^0.0.2: + version "0.0.2" + resolved "https://registry.npmjs.org/ghost-testrpc/-/ghost-testrpc-0.0.2.tgz" + integrity sha512-i08dAEgJ2g8z5buJIrCTduwPIhih3DP+hOCTyyryikfV8T0bNvHnGXO67i0DD1H4GBDETTclPy9njZbfluQYrQ== + dependencies: + chalk "^2.4.2" + node-emoji "^1.10.0" + +glob-parent@^5.1.2, glob-parent@~5.1.0, glob-parent@~5.1.2: + version "5.1.2" + resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz" + integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow== + dependencies: + is-glob "^4.0.1" + +glob-parent@^6.0.1: + version "6.0.2" + resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz" + integrity sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A== + dependencies: + is-glob "^4.0.3" + +glob@7.1.3: + version "7.1.3" + resolved "https://registry.npmjs.org/glob/-/glob-7.1.3.tgz" + integrity sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ== + dependencies: + fs.realpath "^1.0.0" + inflight "^1.0.4" + inherits "2" + minimatch "^3.0.4" + once "^1.3.0" + path-is-absolute "^1.0.0" + +glob@7.1.7: + version "7.1.7" + resolved "https://registry.npmjs.org/glob/-/glob-7.1.7.tgz" + integrity sha512-OvD9ENzPLbegENnYP5UUfJIirTg4+XwMWGaQfQTY0JenxNvvIKP3U3/tAQSPIu/lHxXYSZmpXlUHeqAIdKzBLQ== + dependencies: + fs.realpath "^1.0.0" + inflight "^1.0.4" + inherits "2" + minimatch "^3.0.4" + once "^1.3.0" + path-is-absolute "^1.0.0" + +glob@7.2.0, glob@^7.0.0, glob@^7.1.2, glob@^7.1.3, glob@~7.2.0: + version "7.2.0" + resolved "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz" + integrity sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q== + dependencies: + fs.realpath "^1.0.0" + inflight "^1.0.4" + inherits "2" + minimatch "^3.0.4" + once "^1.3.0" + path-is-absolute "^1.0.0" + +glob@^5.0.15: + version "5.0.15" + resolved "https://registry.npmjs.org/glob/-/glob-5.0.15.tgz" + integrity sha1-G8k2ueAvSmA/zCIuz3Yz0wuLk7E= + dependencies: + inflight "^1.0.4" + inherits "2" + minimatch "2 || 3" + once "^1.3.0" + path-is-absolute "^1.0.0" + +global-modules@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/global-modules/-/global-modules-2.0.0.tgz" + integrity sha512-NGbfmJBp9x8IxyJSd1P+otYK8vonoJactOogrVfFRIAEY1ukil8RSKDz2Yo7wh1oihl51l/r6W4epkeKJHqL8A== + dependencies: + global-prefix "^3.0.0" + +global-prefix@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/global-prefix/-/global-prefix-3.0.0.tgz" + integrity sha512-awConJSVCHVGND6x3tmMaKcQvwXLhjdkmomy2W+Goaui8YPgYgXJZewhg3fWC+DlfqqQuWg8AwqjGTD2nAPVWg== + dependencies: + ini "^1.3.5" + kind-of "^6.0.2" + which "^1.3.1" + +global@~4.4.0: + version "4.4.0" + resolved "https://registry.npmjs.org/global/-/global-4.4.0.tgz" + integrity sha512-wv/LAoHdRE3BeTGz53FAamhGlPLhlssK45usmGFThIi4XqnBmjKQ16u+RNbP7WvigRZDxUsM0J3gcQ5yicaL0w== + dependencies: + min-document "^2.19.0" + process "^0.11.10" + +globals@^11.7.0: + version "11.12.0" + resolved "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz" + integrity sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA== + +globals@^13.6.0, globals@^13.9.0: + version "13.13.0" + resolved "https://registry.npmjs.org/globals/-/globals-13.13.0.tgz" + integrity sha512-EQ7Q18AJlPwp3vUDL4mKA0KXrXyNIQyWon6T6XQiBQF0XHvRsiCSrWmmeATpUzdJN2HhWZU6Pdl0a9zdep5p6A== + dependencies: + type-fest "^0.20.2" + +globals@^9.18.0: + version "9.18.0" + resolved "https://registry.npmjs.org/globals/-/globals-9.18.0.tgz" + integrity sha512-S0nG3CLEQiY/ILxqtztTWH/3iRRdyBLw6KMDxnKMchrtbj2OFmehVh0WUCfW3DUrIgx/qFrJPICrq4Z4sTR9UQ== + +globby@^10.0.1: + version "10.0.2" + resolved "https://registry.npmjs.org/globby/-/globby-10.0.2.tgz" + integrity sha512-7dUi7RvCoT/xast/o/dLN53oqND4yk0nsHkhRgn9w65C4PofCLOoJ39iSOg+qVDdWQPIEj+eszMHQ+aLVwwQSg== + dependencies: + "@types/glob" "^7.1.1" + array-union "^2.1.0" + dir-glob "^3.0.1" + fast-glob "^3.0.3" + glob "^7.1.3" + ignore "^5.1.1" + merge2 "^1.2.3" + slash "^3.0.0" + +globby@^11.0.4: + version "11.1.0" + resolved "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz" + integrity sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g== + dependencies: + array-union "^2.1.0" + dir-glob "^3.0.1" + fast-glob "^3.2.9" + ignore "^5.2.0" + merge2 "^1.4.1" + slash "^3.0.0" + +got@9.6.0: + version "9.6.0" + resolved "https://registry.npmjs.org/got/-/got-9.6.0.tgz" + integrity sha512-R7eWptXuGYxwijs0eV+v3o6+XH1IqVK8dJOEecQfTmkncw9AV4dcw/Dhxi8MdlqPthxxpZyizMzyg8RTmEsG+Q== + dependencies: + "@sindresorhus/is" "^0.14.0" + "@szmarczak/http-timer" "^1.1.2" + cacheable-request "^6.0.0" + decompress-response "^3.3.0" + duplexer3 "^0.1.4" + get-stream "^4.1.0" + lowercase-keys "^1.0.1" + mimic-response "^1.0.1" + p-cancelable "^1.0.0" + to-readable-stream "^1.0.0" + url-parse-lax "^3.0.0" + +got@^7.1.0: + version "7.1.0" + resolved "https://registry.npmjs.org/got/-/got-7.1.0.tgz" + integrity sha512-Y5WMo7xKKq1muPsxD+KmrR8DH5auG7fBdDVueZwETwV6VytKyU9OX/ddpq2/1hp1vIPvVb4T81dKQz3BivkNLw== + dependencies: + decompress-response "^3.2.0" + duplexer3 "^0.1.4" + get-stream "^3.0.0" + is-plain-obj "^1.1.0" + is-retry-allowed "^1.0.0" + is-stream "^1.0.0" + isurl "^1.0.0-alpha5" + lowercase-keys "^1.0.0" + p-cancelable "^0.3.0" + p-timeout "^1.1.1" + safe-buffer "^5.0.1" + timed-out "^4.0.0" + url-parse-lax "^1.0.0" + url-to-options "^1.0.1" + +graceful-fs@^4.1.11, graceful-fs@^4.1.2, graceful-fs@^4.1.6, graceful-fs@^4.1.9, graceful-fs@^4.2.0, graceful-fs@^4.2.4: + version "4.2.10" + resolved "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.10.tgz" + integrity sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA== + +growl@1.10.5: + version "1.10.5" + resolved "https://registry.npmjs.org/growl/-/growl-1.10.5.tgz" + integrity sha512-qBr4OuELkhPenW6goKVXiv47US3clb3/IbuWF9KNKEijAy9oeHxU9IgzjvJhHkUzhaj7rOUD7+YGWqUjLp5oSA== + +handlebars@^4.0.1: + version "4.7.7" + resolved "https://registry.npmjs.org/handlebars/-/handlebars-4.7.7.tgz" + integrity sha512-aAcXm5OAfE/8IXkcZvCepKU3VzW1/39Fb5ZuqMtgI/hT8X2YgoMvBY5dLhq/cpOvw7Lk1nK/UF71aLG/ZnVYRA== + dependencies: + minimist "^1.2.5" + neo-async "^2.6.0" + source-map "^0.6.1" + wordwrap "^1.0.0" + optionalDependencies: + uglify-js "^3.1.4" + +har-schema@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/har-schema/-/har-schema-2.0.0.tgz" + integrity sha1-qUwiJOvKwEeCoNkDVSHyRzW37JI= + +har-validator@~5.1.3: + version "5.1.5" + resolved "https://registry.npmjs.org/har-validator/-/har-validator-5.1.5.tgz" + integrity sha512-nmT2T0lljbxdQZfspsno9hgrG3Uir6Ks5afism62poxqBM6sDnMEuPmzTq8XN0OEwqKLLdh1jQI3qyE66Nzb3w== + dependencies: + ajv "^6.12.3" + har-schema "^2.0.0" + +hardhat-deploy@^0.11.10: + version "0.11.10" + resolved "https://registry.yarnpkg.com/hardhat-deploy/-/hardhat-deploy-0.11.10.tgz#5d34020ae2d475a9278d5dd5f493d86290a35b4d" + integrity sha512-Iby2WhDuAdaKXFkcrMbaA9YWOgDMBnuwixCk4TfBBu8+mBGI9muYsbU/pCMkKfXA4MwSHENweJlfDMyyz7zcNA== + dependencies: + "@types/qs" "^6.9.7" + axios "^0.21.1" + chalk "^4.1.2" + chokidar "^3.5.2" + debug "^4.3.2" + enquirer "^2.3.6" + ethers "^5.5.3" + form-data "^4.0.0" + fs-extra "^10.0.0" + match-all "^1.2.6" + murmur-128 "^0.2.1" + qs "^6.9.4" + zksync-web3 "^0.4.0" + +hardhat-gas-reporter@^1.0.7: + version "1.0.8" + resolved "https://registry.npmjs.org/hardhat-gas-reporter/-/hardhat-gas-reporter-1.0.8.tgz" + integrity sha512-1G5thPnnhcwLHsFnl759f2tgElvuwdkzxlI65fC9PwxYMEe9cmjkVAAWTf3/3y8uP6ZSPiUiOW8PgZnykmZe0g== + dependencies: + array-uniq "1.0.3" + eth-gas-reporter "^0.2.24" + sha1 "^1.1.1" + +"hardhat@https://github.com/0age/hardhat/releases/download/viaIR-2.9.3/hardhat-v2.9.3.tgz": + version "2.9.3" + resolved "https://github.com/0age/hardhat/releases/download/viaIR-2.9.3/hardhat-v2.9.3.tgz" + integrity sha512-+7Oz41IJLHmJXuL0/FqE9k3VaA4qJlUiU3j/bg3lq0yh3O6Oy6677cdVZU80Wc9MPpQv8BzLwvfT1UbmABWo3Q== + dependencies: + "@ethereumjs/block" "^3.6.0" + "@ethereumjs/blockchain" "^5.5.0" + "@ethereumjs/common" "^2.6.0" + "@ethereumjs/tx" "^3.4.0" + "@ethereumjs/vm" "^5.6.0" + "@ethersproject/abi" "^5.1.2" + "@metamask/eth-sig-util" "^4.0.0" + "@sentry/node" "^5.18.1" + "@solidity-parser/parser" "^0.14.1" + "@types/bn.js" "^5.1.0" + "@types/lru-cache" "^5.1.0" + abort-controller "^3.0.0" + adm-zip "^0.4.16" + aggregate-error "^3.0.0" + ansi-escapes "^4.3.0" + chalk "^2.4.2" + chokidar "^3.4.0" + ci-info "^2.0.0" + debug "^4.1.1" + enquirer "^2.3.0" + env-paths "^2.2.0" + ethereum-cryptography "^0.1.2" + ethereumjs-abi "^0.6.8" + ethereumjs-util "^7.1.3" + find-up "^2.1.0" + fp-ts "1.19.3" + fs-extra "^7.0.1" + glob "^7.1.3" + immutable "^4.0.0-rc.12" + io-ts "1.10.4" + lodash "^4.17.11" + merkle-patricia-tree "^4.2.2" + mnemonist "^0.38.0" + mocha "^9.2.0" + p-map "^4.0.0" + qs "^6.7.0" + raw-body "^2.4.1" + resolve "1.17.0" + semver "^6.3.0" + slash "^3.0.0" + solc "0.7.3" + source-map-support "^0.5.13" + stacktrace-parser "^0.1.10" + "true-case-path" "^2.2.1" + tsort "0.0.1" + undici "^4.14.1" + uuid "^8.3.2" + ws "^7.4.6" + +has-ansi@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/has-ansi/-/has-ansi-2.0.0.tgz" + integrity sha1-NPUEnOHs3ysGSa8+8k5F7TVBbZE= + dependencies: + ansi-regex "^2.0.0" + +has-bigints@^1.0.1, has-bigints@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/has-bigints/-/has-bigints-1.0.2.tgz" + integrity sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ== + +has-flag@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/has-flag/-/has-flag-1.0.0.tgz" + integrity sha1-nZ55MWXOAXoA8AQYxD+UKnsdEfo= + +has-flag@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz" + integrity sha1-tdRU3CGZriJWmfNGfloH87lVuv0= + +has-flag@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz" + integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ== + +has-property-descriptors@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz" + integrity sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ== + dependencies: + get-intrinsic "^1.1.1" + +has-symbol-support-x@^1.4.1: + version "1.4.2" + resolved "https://registry.npmjs.org/has-symbol-support-x/-/has-symbol-support-x-1.4.2.tgz" + integrity sha512-3ToOva++HaW+eCpgqZrCfN51IPB+7bJNVT6CUATzueB5Heb8o6Nam0V3HG5dlDvZU1Gn5QLcbahiKw/XVk5JJw== + +has-symbols@^1.0.0, has-symbols@^1.0.1, has-symbols@^1.0.2, has-symbols@^1.0.3: + version "1.0.3" + resolved "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz" + integrity sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A== + +has-to-string-tag-x@^1.2.0: + version "1.4.1" + resolved "https://registry.npmjs.org/has-to-string-tag-x/-/has-to-string-tag-x-1.4.1.tgz" + integrity sha512-vdbKfmw+3LoOYVr+mtxHaX5a96+0f3DljYd8JOqvOLsf5mw2Otda2qCDT9qRqLAhrjyQ0h7ual5nOiASpsGNFw== + dependencies: + has-symbol-support-x "^1.4.1" + +has-tostringtag@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.0.tgz" + integrity sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ== + dependencies: + has-symbols "^1.0.2" + +has-value@^0.3.1: + version "0.3.1" + resolved "https://registry.npmjs.org/has-value/-/has-value-0.3.1.tgz" + integrity sha1-ex9YutpiyoJ+wKIHgCVlSEWZXh8= + dependencies: + get-value "^2.0.3" + has-values "^0.1.4" + isobject "^2.0.0" + +has-value@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/has-value/-/has-value-1.0.0.tgz" + integrity sha1-GLKB2lhbHFxR3vJMkw7SmgvmsXc= + dependencies: + get-value "^2.0.6" + has-values "^1.0.0" + isobject "^3.0.0" + +has-values@^0.1.4: + version "0.1.4" + resolved "https://registry.npmjs.org/has-values/-/has-values-0.1.4.tgz" + integrity sha1-bWHeldkd/Km5oCCJrThL/49it3E= + +has-values@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/has-values/-/has-values-1.0.0.tgz" + integrity sha1-lbC2P+whRmGab+V/51Yo1aOe/k8= + dependencies: + is-number "^3.0.0" + kind-of "^4.0.0" + +has@^1.0.3, has@~1.0.3: + version "1.0.3" + resolved "https://registry.npmjs.org/has/-/has-1.0.3.tgz" + integrity sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw== + dependencies: + function-bind "^1.1.1" + +hash-base@^3.0.0: + version "3.1.0" + resolved "https://registry.npmjs.org/hash-base/-/hash-base-3.1.0.tgz" + integrity sha512-1nmYp/rhMDiE7AYkDw+lLwlAzz0AntGIe51F3RfFfEqyQ3feY2eI/NcwC6umIQVOASPMsWJLJScWKSSvzL9IVA== + dependencies: + inherits "^2.0.4" + readable-stream "^3.6.0" + safe-buffer "^5.2.0" + +hash.js@1.1.3: + version "1.1.3" + resolved "https://registry.npmjs.org/hash.js/-/hash.js-1.1.3.tgz" + integrity sha512-/UETyP0W22QILqS+6HowevwhEFJ3MBJnwTf75Qob9Wz9t0DPuisL8kW8YZMK62dHAKE1c1p+gY1TtOLY+USEHA== + dependencies: + inherits "^2.0.3" + minimalistic-assert "^1.0.0" + +hash.js@1.1.7, hash.js@^1.0.0, hash.js@^1.0.3, hash.js@^1.1.7: + version "1.1.7" + resolved "https://registry.npmjs.org/hash.js/-/hash.js-1.1.7.tgz" + integrity sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA== + dependencies: + inherits "^2.0.3" + minimalistic-assert "^1.0.1" + +he@1.2.0: + version "1.2.0" + resolved "https://registry.npmjs.org/he/-/he-1.2.0.tgz" + integrity sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw== + +heap@0.2.6: + version "0.2.6" + resolved "https://registry.npmjs.org/heap/-/heap-0.2.6.tgz" + integrity sha1-CH4fELBGky/IWU3Z5tN4r8nR5aw= + +hmac-drbg@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/hmac-drbg/-/hmac-drbg-1.0.1.tgz" + integrity sha1-0nRXAQJabHdabFRXk+1QL8DGSaE= + dependencies: + hash.js "^1.0.3" + minimalistic-assert "^1.0.0" + minimalistic-crypto-utils "^1.0.1" + +home-or-tmp@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/home-or-tmp/-/home-or-tmp-2.0.0.tgz" + integrity sha1-42w/LSyufXRqhX440Y1fMqeILbg= + dependencies: + os-homedir "^1.0.0" + os-tmpdir "^1.0.1" + +hosted-git-info@^2.1.4, hosted-git-info@^2.6.0: + version "2.8.9" + resolved "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.9.tgz" + integrity sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw== + +http-basic@^8.1.1: + version "8.1.3" + resolved "https://registry.npmjs.org/http-basic/-/http-basic-8.1.3.tgz" + integrity sha512-/EcDMwJZh3mABI2NhGfHOGOeOZITqfkEO4p/xK+l3NpyncIHUQBoMvCSF/b5GqvKtySC2srL/GGG3+EtlqlmCw== + dependencies: + caseless "^0.12.0" + concat-stream "^1.6.2" + http-response-object "^3.0.1" + parse-cache-control "^1.0.1" + +http-cache-semantics@^4.0.0: + version "4.1.0" + resolved "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.1.0.tgz" + integrity sha512-carPklcUh7ROWRK7Cv27RPtdhYhUsela/ue5/jKzjegVvXDqM2ILE9Q2BGn9JZJh1g87cp56su/FgQSzcWS8cQ== + +http-errors@2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz" + integrity sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ== + dependencies: + depd "2.0.0" + inherits "2.0.4" + setprototypeof "1.2.0" + statuses "2.0.1" + toidentifier "1.0.1" + +http-https@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/http-https/-/http-https-1.0.0.tgz" + integrity sha1-L5CN1fHbQGjAWM1ubUzjkskTOJs= + +http-response-object@^3.0.1: + version "3.0.2" + resolved "https://registry.npmjs.org/http-response-object/-/http-response-object-3.0.2.tgz" + integrity sha512-bqX0XTF6fnXSQcEJ2Iuyr75yVakyjIDCqroJQ/aHfSdlM743Cwqoi2nDYMzLGWUcuTWGWy8AAvOKXTfiv6q9RA== + dependencies: + "@types/node" "^10.0.3" + +http-signature@~1.2.0: + version "1.2.0" + resolved "https://registry.npmjs.org/http-signature/-/http-signature-1.2.0.tgz" + integrity sha1-muzZJRFHcvPZW2WmCruPfBj7rOE= + dependencies: + assert-plus "^1.0.0" + jsprim "^1.2.2" + sshpk "^1.7.0" + +https-proxy-agent@^5.0.0: + version "5.0.1" + resolved "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz" + integrity sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA== + dependencies: + agent-base "6" + debug "4" + +human-signals@^2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/human-signals/-/human-signals-2.1.0.tgz" + integrity sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw== + +husky@>=6: + version "7.0.4" + resolved "https://registry.npmjs.org/husky/-/husky-7.0.4.tgz" + integrity sha512-vbaCKN2QLtP/vD4yvs6iz6hBEo6wkSzs8HpRah1Z6aGmF2KW5PdYuAd7uX5a+OyBZHBhd+TFLqgjUgytQr4RvQ== + +iconv-lite@0.4.24, iconv-lite@^0.4.24: + version "0.4.24" + resolved "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz" + integrity sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA== + dependencies: + safer-buffer ">= 2.1.2 < 3" + +idna-uts46-hx@^2.3.1: + version "2.3.1" + resolved "https://registry.npmjs.org/idna-uts46-hx/-/idna-uts46-hx-2.3.1.tgz" + integrity sha512-PWoF9Keq6laYdIRwwCdhTPl60xRqAloYNMQLiyUnG42VjT53oW07BXIRM+NK7eQjzXjAk2gUvX9caRxlnF9TAA== + dependencies: + punycode "2.1.0" + +ieee754@^1.1.13: + version "1.2.1" + resolved "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz" + integrity sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA== + +ignore@^4.0.6: + version "4.0.6" + resolved "https://registry.npmjs.org/ignore/-/ignore-4.0.6.tgz" + integrity sha512-cyFDKrqc/YdcWFniJhzI42+AzS+gNwmUzOSFcRCQYwySuBBBy/KjuxWLZ/FHEH6Moq1NizMOBWyTcv8O4OZIMg== + +ignore@^5.1.1, ignore@^5.1.8, ignore@^5.2.0: + version "5.2.0" + resolved "https://registry.npmjs.org/ignore/-/ignore-5.2.0.tgz" + integrity sha512-CmxgYGiEPCLhfLnpPp1MoRmifwEIOgjcHXxOBjv7mY96c+eWScsOP9c112ZyLdWHi0FxHjI+4uVhKYp/gcdRmQ== + +immediate@^3.2.3, immediate@~3.2.3: + version "3.2.3" + resolved "https://registry.npmjs.org/immediate/-/immediate-3.2.3.tgz" + integrity sha1-0UD6j2FGWb1lQSMwl92qwlzdmRw= + +immutable@^4.0.0-rc.12: + version "4.0.0" + resolved "https://registry.npmjs.org/immutable/-/immutable-4.0.0.tgz" + integrity sha512-zIE9hX70qew5qTUjSS7wi1iwj/l7+m54KWU247nhM3v806UdGj1yDndXj+IOYxxtW9zyLI+xqFNZjTuDaLUqFw== + +import-fresh@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/import-fresh/-/import-fresh-2.0.0.tgz" + integrity sha1-2BNVwVYS04bGH53dOSLUMEgipUY= + dependencies: + caller-path "^2.0.0" + resolve-from "^3.0.0" + +import-fresh@^3.0.0, import-fresh@^3.2.1: + version "3.3.0" + resolved "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz" + integrity sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw== + dependencies: + parent-module "^1.0.0" + resolve-from "^4.0.0" + +imul@^1.0.0: + version "1.0.1" + resolved "https://registry.yarnpkg.com/imul/-/imul-1.0.1.tgz#9d5867161e8b3de96c2c38d5dc7cb102f35e2ac9" + integrity sha512-WFAgfwPLAjU66EKt6vRdTlKj4nAgIDQzh29JonLa4Bqtl6D8JrIMvWjCnx7xEjVNmP3U0fM5o8ZObk7d0f62bA== + +imurmurhash@^0.1.4: + version "0.1.4" + resolved "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz" + integrity sha1-khi5srkoojixPcT7a21XbyMUU+o= + +indent-string@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz" + integrity sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg== + +inflight@^1.0.4: + version "1.0.6" + resolved "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz" + integrity sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk= + dependencies: + once "^1.3.0" + wrappy "1" + +inherits@2, inherits@2.0.4, inherits@^2.0.1, inherits@^2.0.3, inherits@^2.0.4, inherits@~2.0.1, inherits@~2.0.3, inherits@~2.0.4: + version "2.0.4" + resolved "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz" + integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ== + +ini@^1.3.5: + version "1.3.8" + resolved "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz" + integrity sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew== + +inquirer@^6.2.2: + version "6.5.2" + resolved "https://registry.npmjs.org/inquirer/-/inquirer-6.5.2.tgz" + integrity sha512-cntlB5ghuB0iuO65Ovoi8ogLHiWGs/5yNrtUcKjFhSSiVeAIVpD7koaSU9RM8mpXw5YDi9RdYXGQMaOURB7ycQ== + dependencies: + ansi-escapes "^3.2.0" + chalk "^2.4.2" + cli-cursor "^2.1.0" + cli-width "^2.0.0" + external-editor "^3.0.3" + figures "^2.0.0" + lodash "^4.17.12" + mute-stream "0.0.7" + run-async "^2.2.0" + rxjs "^6.4.0" + string-width "^2.1.0" + strip-ansi "^5.1.0" + through "^2.3.6" + +internal-slot@^1.0.3: + version "1.0.3" + resolved "https://registry.npmjs.org/internal-slot/-/internal-slot-1.0.3.tgz" + integrity sha512-O0DB1JC/sPyZl7cIo78n5dR7eUSwwpYPiXRhTzNxZVAMUuB8vlnRFyLxdrVToks6XPLVnFfbzaVd5WLjhgg+vA== + dependencies: + get-intrinsic "^1.1.0" + has "^1.0.3" + side-channel "^1.0.4" + +interpret@^1.0.0: + version "1.4.0" + resolved "https://registry.npmjs.org/interpret/-/interpret-1.4.0.tgz" + integrity sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA== + +invariant@^2.2.2: + version "2.2.4" + resolved "https://registry.npmjs.org/invariant/-/invariant-2.2.4.tgz" + integrity sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA== + dependencies: + loose-envify "^1.0.0" + +invert-kv@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/invert-kv/-/invert-kv-1.0.0.tgz" + integrity sha1-EEqOSqym09jNFXqO+L+rLXo//bY= + +io-ts@1.10.4: + version "1.10.4" + resolved "https://registry.npmjs.org/io-ts/-/io-ts-1.10.4.tgz" + integrity sha512-b23PteSnYXSONJ6JQXRAlvJhuw8KOtkqa87W4wDtvMrud/DTJd5X+NpOOI+O/zZwVq6v0VLAaJ+1EDViKEuN9g== + dependencies: + fp-ts "^1.0.0" + +ipaddr.js@1.9.1: + version "1.9.1" + resolved "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz" + integrity sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g== + +is-accessor-descriptor@^0.1.6: + version "0.1.6" + resolved "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz" + integrity sha1-qeEss66Nh2cn7u84Q/igiXtcmNY= + dependencies: + kind-of "^3.0.2" + +is-accessor-descriptor@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz" + integrity sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ== + dependencies: + kind-of "^6.0.0" + +is-arguments@^1.0.4: + version "1.1.1" + resolved "https://registry.npmjs.org/is-arguments/-/is-arguments-1.1.1.tgz" + integrity sha512-8Q7EARjzEnKpt/PCD7e1cgUS0a6X8u5tdSiMqXhojOdoV9TsMsiO+9VLC5vAmO8N7/GmXn7yjR8qnA6bVAEzfA== + dependencies: + call-bind "^1.0.2" + has-tostringtag "^1.0.0" + +is-arrayish@^0.2.1: + version "0.2.1" + resolved "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz" + integrity sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0= + +is-bigint@^1.0.1: + version "1.0.4" + resolved "https://registry.npmjs.org/is-bigint/-/is-bigint-1.0.4.tgz" + integrity sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg== + dependencies: + has-bigints "^1.0.1" + +is-binary-path@~2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz" + integrity sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw== + dependencies: + binary-extensions "^2.0.0" + +is-boolean-object@^1.1.0: + version "1.1.2" + resolved "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.1.2.tgz" + integrity sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA== + dependencies: + call-bind "^1.0.2" + has-tostringtag "^1.0.0" + +is-buffer@^1.1.5: + version "1.1.6" + resolved "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.6.tgz" + integrity sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w== + +is-buffer@~2.0.3: + version "2.0.5" + resolved "https://registry.npmjs.org/is-buffer/-/is-buffer-2.0.5.tgz" + integrity sha512-i2R6zNFDwgEHJyQUtJEk0XFi1i0dPFn/oqjK3/vPCcDeJvW5NQ83V8QbicfF1SupOaB0h8ntgBC2YiE7dfyctQ== + +is-callable@^1.1.3, is-callable@^1.1.4, is-callable@^1.2.4: + version "1.2.4" + resolved "https://registry.npmjs.org/is-callable/-/is-callable-1.2.4.tgz" + integrity sha512-nsuwtxZfMX67Oryl9LCQ+upnC0Z0BgpwntpS89m1H/TLF0zNfzfLMV/9Wa/6MZsj0acpEjAO0KF1xT6ZdLl95w== + +is-ci@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/is-ci/-/is-ci-2.0.0.tgz" + integrity sha512-YfJT7rkpQB0updsdHLGWrvhBJfcfzNNawYDNIyQXJz0IViGf75O8EBPKSdvw2rF+LGCsX4FZ8tcr3b19LcZq4w== + dependencies: + ci-info "^2.0.0" + +is-core-module@^2.8.1, is-core-module@^2.9.0: + version "2.9.0" + resolved "https://registry.npmjs.org/is-core-module/-/is-core-module-2.9.0.tgz" + integrity sha512-+5FPy5PnwmO3lvfMb0AsoPaBG+5KHUI0wYFXOtYPnVVVspTFUuMZNfNaNVRt3FZadstu2c8x23vykRW/NBoU6A== + dependencies: + has "^1.0.3" + +is-data-descriptor@^0.1.4: + version "0.1.4" + resolved "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz" + integrity sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y= + dependencies: + kind-of "^3.0.2" + +is-data-descriptor@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz" + integrity sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ== + dependencies: + kind-of "^6.0.0" + +is-date-object@^1.0.1: + version "1.0.5" + resolved "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.5.tgz" + integrity sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ== + dependencies: + has-tostringtag "^1.0.0" + +is-descriptor@^0.1.0: + version "0.1.6" + resolved "https://registry.npmjs.org/is-descriptor/-/is-descriptor-0.1.6.tgz" + integrity sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg== + dependencies: + is-accessor-descriptor "^0.1.6" + is-data-descriptor "^0.1.4" + kind-of "^5.0.0" + +is-descriptor@^1.0.0, is-descriptor@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz" + integrity sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg== + dependencies: + is-accessor-descriptor "^1.0.0" + is-data-descriptor "^1.0.0" + kind-of "^6.0.2" + +is-directory@^0.3.1: + version "0.3.1" + resolved "https://registry.npmjs.org/is-directory/-/is-directory-0.3.1.tgz" + integrity sha1-YTObbyR1/Hcv2cnYP1yFddwVSuE= + +is-docker@^2.0.0: + version "2.2.1" + resolved "https://registry.npmjs.org/is-docker/-/is-docker-2.2.1.tgz" + integrity sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ== + +is-extendable@^0.1.0, is-extendable@^0.1.1: + version "0.1.1" + resolved "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz" + integrity sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik= + +is-extendable@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz" + integrity sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA== + dependencies: + is-plain-object "^2.0.4" + +is-extglob@^2.1.1: + version "2.1.1" + resolved "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz" + integrity sha1-qIwCU1eR8C7TfHahueqXc8gz+MI= + +is-finite@^1.0.0: + version "1.1.0" + resolved "https://registry.npmjs.org/is-finite/-/is-finite-1.1.0.tgz" + integrity sha512-cdyMtqX/BOqqNBBiKlIVkytNHm49MtMlYyn1zxzvJKWmFMlGzm+ry5BBfYyeY9YmNKbRSo/o7OX9w9ale0wg3w== + +is-fn@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/is-fn/-/is-fn-1.0.0.tgz" + integrity sha1-lUPV3nvPWwiiLsiiC65uKG1RDYw= + +is-fullwidth-code-point@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz" + integrity sha1-754xOG8DGn8NZDr4L95QxFfvAMs= + dependencies: + number-is-nan "^1.0.0" + +is-fullwidth-code-point@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz" + integrity sha1-o7MKXE8ZkYMWeqq5O+764937ZU8= + +is-fullwidth-code-point@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz" + integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg== + +is-fullwidth-code-point@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-4.0.0.tgz" + integrity sha512-O4L094N2/dZ7xqVdrXhh9r1KODPJpFms8B5sGdJLPy664AgvXsreZUyCQQNItZRDlYug4xStLjNp/sz3HvBowQ== + +is-function@^1.0.1: + version "1.0.2" + resolved "https://registry.npmjs.org/is-function/-/is-function-1.0.2.tgz" + integrity sha512-lw7DUp0aWXYg+CBCN+JKkcE0Q2RayZnSvnZBlwgxHBQhqt5pZNVy4Ri7H9GmmXkdu7LUthszM+Tor1u/2iBcpQ== + +is-generator-function@^1.0.7: + version "1.0.10" + resolved "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.0.10.tgz" + integrity sha512-jsEjy9l3yiXEQ+PsXdmBwEPcOxaXWLspKdplFUVI9vq1iZgIekeC0L167qeu86czQaxed3q/Uzuw0swL0irL8A== + dependencies: + has-tostringtag "^1.0.0" + +is-glob@^4.0.0, is-glob@^4.0.1, is-glob@^4.0.3, is-glob@~4.0.1: + version "4.0.3" + resolved "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz" + integrity sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg== + dependencies: + is-extglob "^2.1.1" + +is-hex-prefixed@1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/is-hex-prefixed/-/is-hex-prefixed-1.0.0.tgz" + integrity sha1-fY035q135dEnFIkTxXPggtd39VQ= + +is-negative-zero@^2.0.2: + version "2.0.2" + resolved "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.2.tgz" + integrity sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA== + +is-number-object@^1.0.4: + version "1.0.7" + resolved "https://registry.npmjs.org/is-number-object/-/is-number-object-1.0.7.tgz" + integrity sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ== + dependencies: + has-tostringtag "^1.0.0" + +is-number@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz" + integrity sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU= + dependencies: + kind-of "^3.0.2" + +is-number@^7.0.0: + version "7.0.0" + resolved "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz" + integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng== + +is-object@^1.0.1: + version "1.0.2" + resolved "https://registry.npmjs.org/is-object/-/is-object-1.0.2.tgz" + integrity sha512-2rRIahhZr2UWb45fIOuvZGpFtz0TyOZLf32KxBbSoUCeZR495zCKlWUKKUByk3geS2eAs7ZAABt0Y/Rx0GiQGA== + +is-plain-obj@^1.1.0: + version "1.1.0" + resolved "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-1.1.0.tgz" + integrity sha1-caUMhCnfync8kqOQpKA7OfzVHT4= + +is-plain-obj@^2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz" + integrity sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA== + +is-plain-object@^2.0.3, is-plain-object@^2.0.4: + version "2.0.4" + resolved "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz" + integrity sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og== + dependencies: + isobject "^3.0.1" + +is-regex@^1.0.4, is-regex@^1.1.4, is-regex@~1.1.4: + version "1.1.4" + resolved "https://registry.npmjs.org/is-regex/-/is-regex-1.1.4.tgz" + integrity sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg== + dependencies: + call-bind "^1.0.2" + has-tostringtag "^1.0.0" + +is-retry-allowed@^1.0.0: + version "1.2.0" + resolved "https://registry.npmjs.org/is-retry-allowed/-/is-retry-allowed-1.2.0.tgz" + integrity sha512-RUbUeKwvm3XG2VYamhJL1xFktgjvPzL0Hq8C+6yrWIswDy3BIXGqCxhxkc30N9jqK311gVU137K8Ei55/zVJRg== + +is-shared-array-buffer@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.2.tgz" + integrity sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA== + dependencies: + call-bind "^1.0.2" + +is-stream@^1.0.0: + version "1.1.0" + resolved "https://registry.npmjs.org/is-stream/-/is-stream-1.1.0.tgz" + integrity sha1-EtSj3U5o4Lec6428hBc66A2RykQ= + +is-stream@^2.0.0: + version "2.0.1" + resolved "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz" + integrity sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg== + +is-string@^1.0.5, is-string@^1.0.7: + version "1.0.7" + resolved "https://registry.npmjs.org/is-string/-/is-string-1.0.7.tgz" + integrity sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg== + dependencies: + has-tostringtag "^1.0.0" + +is-symbol@^1.0.2, is-symbol@^1.0.3: + version "1.0.4" + resolved "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.4.tgz" + integrity sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg== + dependencies: + has-symbols "^1.0.2" + +is-typed-array@^1.1.3, is-typed-array@^1.1.7: + version "1.1.8" + resolved "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.8.tgz" + integrity sha512-HqH41TNZq2fgtGT8WHVFVJhBVGuY3AnP3Q36K8JKXUxSxRgk/d+7NjmwG2vo2mYmXK8UYZKu0qH8bVP5gEisjA== + dependencies: + available-typed-arrays "^1.0.5" + call-bind "^1.0.2" + es-abstract "^1.18.5" + foreach "^2.0.5" + has-tostringtag "^1.0.0" + +is-typedarray@^1.0.0, is-typedarray@~1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz" + integrity sha1-5HnICFjfDBsR3dppQPlgEfzaSpo= + +is-unicode-supported@^0.1.0: + version "0.1.0" + resolved "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz" + integrity sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw== + +is-url@^1.2.4: + version "1.2.4" + resolved "https://registry.npmjs.org/is-url/-/is-url-1.2.4.tgz" + integrity sha512-ITvGim8FhRiYe4IQ5uHSkj7pVaPDrCTkNd3yq3cV7iZAcJdHTUMPMEHcqSOy9xZ9qFenQCvi+2wjH9a1nXqHww== + +is-utf8@^0.2.0: + version "0.2.1" + resolved "https://registry.npmjs.org/is-utf8/-/is-utf8-0.2.1.tgz" + integrity sha1-Sw2hRCEE0bM2NA6AeX6GXPOffXI= + +is-weakref@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/is-weakref/-/is-weakref-1.0.2.tgz" + integrity sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ== + dependencies: + call-bind "^1.0.2" + +is-windows@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/is-windows/-/is-windows-1.0.2.tgz" + integrity sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA== + +is-wsl@^2.1.1: + version "2.2.0" + resolved "https://registry.npmjs.org/is-wsl/-/is-wsl-2.2.0.tgz" + integrity sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww== + dependencies: + is-docker "^2.0.0" + +isarray@0.0.1: + version "0.0.1" + resolved "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz" + integrity sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8= + +isarray@1.0.0, isarray@~1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz" + integrity sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE= + +isexe@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz" + integrity sha1-6PvzdNxVb/iUehDcsFctYz8s+hA= + +isobject@^2.0.0: + version "2.1.0" + resolved "https://registry.npmjs.org/isobject/-/isobject-2.1.0.tgz" + integrity sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk= + dependencies: + isarray "1.0.0" + +isobject@^3.0.0, isobject@^3.0.1: + version "3.0.1" + resolved "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz" + integrity sha1-TkMekrEalzFjaqH5yNHMvP2reN8= + +isstream@~0.1.2: + version "0.1.2" + resolved "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz" + integrity sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo= + +isurl@^1.0.0-alpha5: + version "1.0.0" + resolved "https://registry.npmjs.org/isurl/-/isurl-1.0.0.tgz" + integrity sha512-1P/yWsxPlDtn7QeRD+ULKQPaIaN6yF368GZ2vDfv0AL0NwpStafjWCDDdn0k8wgFMWpVAqG7oJhxHnlud42i9w== + dependencies: + has-to-string-tag-x "^1.2.0" + is-object "^1.0.1" + +js-sha3@0.5.7, js-sha3@^0.5.7: + version "0.5.7" + resolved "https://registry.npmjs.org/js-sha3/-/js-sha3-0.5.7.tgz" + integrity sha1-DU/9gALVMzqrr0oj7tL2N0yfKOc= + +js-sha3@0.8.0, js-sha3@^0.8.0: + version "0.8.0" + resolved "https://registry.npmjs.org/js-sha3/-/js-sha3-0.8.0.tgz" + integrity sha512-gF1cRrHhIzNfToc802P800N8PpXS+evLLXfsVpowqmAFR9uwbi89WvXg2QspOmXL8QL86J4T1EpFu+yUkwJY3Q== + +"js-tokens@^3.0.0 || ^4.0.0", js-tokens@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz" + integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ== + +js-tokens@^3.0.2: + version "3.0.2" + resolved "https://registry.npmjs.org/js-tokens/-/js-tokens-3.0.2.tgz" + integrity sha1-mGbfOVECEw449/mWvOtlRDIJwls= + +js-yaml@3.13.1: + version "3.13.1" + resolved "https://registry.npmjs.org/js-yaml/-/js-yaml-3.13.1.tgz" + integrity sha512-YfbcO7jXDdyj0DGxYVSlSeQNHbD7XPWvrVWeVUujrQEoZzWJIRrCPoyk6kL6IAjAG2IolMK4T0hNUe0HOUs5Jw== + dependencies: + argparse "^1.0.7" + esprima "^4.0.0" + +js-yaml@3.x, js-yaml@^3.12.0, js-yaml@^3.13.0, js-yaml@^3.13.1, js-yaml@^3.14.0: + version "3.14.1" + resolved "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz" + integrity sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g== + dependencies: + argparse "^1.0.7" + esprima "^4.0.0" + +js-yaml@4.1.0, js-yaml@^4.1.0: + version "4.1.0" + resolved "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz" + integrity sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA== + dependencies: + argparse "^2.0.1" + +jsbi@^4.1.0: + version "4.3.0" + resolved "https://registry.yarnpkg.com/jsbi/-/jsbi-4.3.0.tgz#b54ee074fb6fcbc00619559305c8f7e912b04741" + integrity sha512-SnZNcinB4RIcnEyZqFPdGPVgrg2AcnykiBy0sHVJQKHYeaLUvi3Exj+iaPpLnFVkDPZIV4U0yvgC9/R4uEAZ9g== + +jsbn@~0.1.0: + version "0.1.1" + resolved "https://registry.npmjs.org/jsbn/-/jsbn-0.1.1.tgz" + integrity sha1-peZUwuWi3rXyAdls77yoDA7y9RM= + +jsesc@^1.3.0: + version "1.3.0" + resolved "https://registry.npmjs.org/jsesc/-/jsesc-1.3.0.tgz" + integrity sha1-RsP+yMGJKxKwgz25vHYiF226s0s= + +jsesc@~0.5.0: + version "0.5.0" + resolved "https://registry.npmjs.org/jsesc/-/jsesc-0.5.0.tgz" + integrity sha1-597mbjXW/Bb3EP6R1c9p9w8IkR0= + +json-buffer@3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.0.tgz" + integrity sha1-Wx85evx11ne96Lz8Dkfh+aPZqJg= + +json-parse-better-errors@^1.0.1: + version "1.0.2" + resolved "https://registry.npmjs.org/json-parse-better-errors/-/json-parse-better-errors-1.0.2.tgz" + integrity sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw== + +json-rpc-engine@^3.4.0, json-rpc-engine@^3.6.0: + version "3.8.0" + resolved "https://registry.npmjs.org/json-rpc-engine/-/json-rpc-engine-3.8.0.tgz" + integrity sha512-6QNcvm2gFuuK4TKU1uwfH0Qd/cOSb9c1lls0gbnIhciktIUQJwz6NQNAW4B1KiGPenv7IKu97V222Yo1bNhGuA== + dependencies: + async "^2.0.1" + babel-preset-env "^1.7.0" + babelify "^7.3.0" + json-rpc-error "^2.0.0" + promise-to-callback "^1.0.0" + safe-event-emitter "^1.0.1" + +json-rpc-error@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/json-rpc-error/-/json-rpc-error-2.0.0.tgz" + integrity sha1-p6+cICg4tekFxyUOVH8a/3cligI= + dependencies: + inherits "^2.0.1" + +json-rpc-random-id@^1.0.0: + version "1.0.1" + resolved "https://registry.npmjs.org/json-rpc-random-id/-/json-rpc-random-id-1.0.1.tgz" + integrity sha1-uknZat7RRE27jaPSA3SKy7zeyMg= + +json-schema-traverse@^0.4.1: + version "0.4.1" + resolved "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz" + integrity sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg== + +json-schema-traverse@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz#ae7bcb3656ab77a73ba5c49bf654f38e6b6860e2" + integrity sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug== + +json-schema@0.4.0: + version "0.4.0" + resolved "https://registry.npmjs.org/json-schema/-/json-schema-0.4.0.tgz" + integrity sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA== + +json-stable-stringify-without-jsonify@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz" + integrity sha1-nbe1lJatPzz+8wp1FC0tkwrXJlE= + +json-stable-stringify@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/json-stable-stringify/-/json-stable-stringify-1.0.1.tgz" + integrity sha1-mnWdOcXy/1A/1TAGRu1EX4jE+a8= + dependencies: + jsonify "~0.0.0" + +json-stringify-safe@~5.0.1: + version "5.0.1" + resolved "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz" + integrity sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus= + +json5@^0.5.1: + version "0.5.1" + resolved "https://registry.npmjs.org/json5/-/json5-0.5.1.tgz" + integrity sha1-Hq3nrMASA0rYTiOWdn6tn6VJWCE= + +json5@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/json5/-/json5-1.0.1.tgz" + integrity sha512-aKS4WQjPenRxiQsC93MNfjx+nbF4PAdYzmd/1JIj8HYzqfbu86beTuNgXDzPknWk0n0uARlyewZo4s++ES36Ow== + dependencies: + minimist "^1.2.0" + +jsonfile@^2.1.0: + version "2.4.0" + resolved "https://registry.npmjs.org/jsonfile/-/jsonfile-2.4.0.tgz" + integrity sha1-NzaitCi4e72gzIO1P6PWM6NcKug= + optionalDependencies: + graceful-fs "^4.1.6" + +jsonfile@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz" + integrity sha1-h3Gq4HmbZAdrdmQPygWPnBDjPss= + optionalDependencies: + graceful-fs "^4.1.6" + +jsonfile@^6.0.1: + version "6.1.0" + resolved "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz" + integrity sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ== + dependencies: + universalify "^2.0.0" + optionalDependencies: + graceful-fs "^4.1.6" + +jsonify@~0.0.0: + version "0.0.0" + resolved "https://registry.npmjs.org/jsonify/-/jsonify-0.0.0.tgz" + integrity sha1-LHS27kHZPKUbe1qu6PUDYx0lKnM= + +jsonschema@^1.2.4: + version "1.4.0" + resolved "https://registry.npmjs.org/jsonschema/-/jsonschema-1.4.0.tgz" + integrity sha512-/YgW6pRMr6M7C+4o8kS+B/2myEpHCrxO4PEWnqJNBFMjn7EWXqlQ4tGwL6xTHeRplwuZmcAncdvfOad1nT2yMw== + +jsprim@^1.2.2: + version "1.4.2" + resolved "https://registry.npmjs.org/jsprim/-/jsprim-1.4.2.tgz" + integrity sha512-P2bSOMAc/ciLz6DzgjVlGJP9+BrJWu5UDGK70C2iweC5QBIeFf0ZXRvGjEj2uYgrY2MkAAhsSWHDWlFtEroZWw== + dependencies: + assert-plus "1.0.0" + extsprintf "1.3.0" + json-schema "0.4.0" + verror "1.10.0" + +keccak@3.0.1: + version "3.0.1" + resolved "https://registry.npmjs.org/keccak/-/keccak-3.0.1.tgz" + integrity sha512-epq90L9jlFWCW7+pQa6JOnKn2Xgl2mtI664seYR6MHskvI9agt7AnDqmAlp9TqU4/caMYbA08Hi5DMZAl5zdkA== + dependencies: + node-addon-api "^2.0.0" + node-gyp-build "^4.2.0" + +keccak@^3.0.0: + version "3.0.2" + resolved "https://registry.npmjs.org/keccak/-/keccak-3.0.2.tgz" + integrity sha512-PyKKjkH53wDMLGrvmRGSNWgmSxZOUqbnXwKL9tmgbFYA1iAYqW21kfR7mZXV0MlESiefxQQE9X9fTa3X+2MPDQ== + dependencies: + node-addon-api "^2.0.0" + node-gyp-build "^4.2.0" + readable-stream "^3.6.0" + +keyv@^3.0.0: + version "3.1.0" + resolved "https://registry.npmjs.org/keyv/-/keyv-3.1.0.tgz" + integrity sha512-9ykJ/46SN/9KPM/sichzQ7OvXyGDYKGTaDlKMGCAlg2UK8KRy4jb0d8sFc+0Tt0YYnThq8X2RZgCg74RPxgcVA== + dependencies: + json-buffer "3.0.0" + +kind-of@^3.0.2, kind-of@^3.0.3, kind-of@^3.2.0: + version "3.2.2" + resolved "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz" + integrity sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ= + dependencies: + is-buffer "^1.1.5" + +kind-of@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/kind-of/-/kind-of-4.0.0.tgz" + integrity sha1-IIE989cSkosgc3hpGkUGb65y3Vc= + dependencies: + is-buffer "^1.1.5" + +kind-of@^5.0.0: + version "5.1.0" + resolved "https://registry.npmjs.org/kind-of/-/kind-of-5.1.0.tgz" + integrity sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw== + +kind-of@^6.0.0, kind-of@^6.0.2: + version "6.0.3" + resolved "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz" + integrity sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw== + +klaw-sync@^6.0.0: + version "6.0.0" + resolved "https://registry.npmjs.org/klaw-sync/-/klaw-sync-6.0.0.tgz" + integrity sha512-nIeuVSzdCCs6TDPTqI8w1Yre34sSq7AkZ4B3sfOBbI2CgVSB4Du4aLQijFU2+lhAFCwt9+42Hel6lQNIv6AntQ== + dependencies: + graceful-fs "^4.1.11" + +klaw@^1.0.0: + version "1.3.1" + resolved "https://registry.npmjs.org/klaw/-/klaw-1.3.1.tgz" + integrity sha1-QIhDO0azsbolnXh4XY6W9zugJDk= + optionalDependencies: + graceful-fs "^4.1.9" + +lcid@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/lcid/-/lcid-1.0.0.tgz" + integrity sha1-MIrMr6C8SDo4Z7S28rlQYlHRuDU= + dependencies: + invert-kv "^1.0.0" + +level-codec@^9.0.0: + version "9.0.2" + resolved "https://registry.npmjs.org/level-codec/-/level-codec-9.0.2.tgz" + integrity sha512-UyIwNb1lJBChJnGfjmO0OR+ezh2iVu1Kas3nvBS/BzGnx79dv6g7unpKIDNPMhfdTEGoc7mC8uAu51XEtX+FHQ== + dependencies: + buffer "^5.6.0" + +level-codec@~7.0.0: + version "7.0.1" + resolved "https://registry.npmjs.org/level-codec/-/level-codec-7.0.1.tgz" + integrity sha512-Ua/R9B9r3RasXdRmOtd+t9TCOEIIlts+TN/7XTT2unhDaL6sJn83S3rUyljbr6lVtw49N3/yA0HHjpV6Kzb2aQ== + +level-concat-iterator@~2.0.0: + version "2.0.1" + resolved "https://registry.npmjs.org/level-concat-iterator/-/level-concat-iterator-2.0.1.tgz" + integrity sha512-OTKKOqeav2QWcERMJR7IS9CUo1sHnke2C0gkSmcR7QuEtFNLLzHQAvnMw8ykvEcv0Qtkg0p7FOwP1v9e5Smdcw== + +level-errors@^1.0.3, level-errors@~1.0.3: + version "1.0.5" + resolved "https://registry.npmjs.org/level-errors/-/level-errors-1.0.5.tgz" + integrity sha512-/cLUpQduF6bNrWuAC4pwtUKA5t669pCsCi2XbmojG2tFeOr9j6ShtdDCtFFQO1DRt+EVZhx9gPzP9G2bUaG4ig== + dependencies: + errno "~0.1.1" + +level-errors@^2.0.0, level-errors@~2.0.0: + version "2.0.1" + resolved "https://registry.npmjs.org/level-errors/-/level-errors-2.0.1.tgz" + integrity sha512-UVprBJXite4gPS+3VznfgDSU8PTRuVX0NXwoWW50KLxd2yw4Y1t2JUR5In1itQnudZqRMT9DlAM3Q//9NCjCFw== + dependencies: + errno "~0.1.1" + +level-iterator-stream@^2.0.3: + version "2.0.3" + resolved "https://registry.npmjs.org/level-iterator-stream/-/level-iterator-stream-2.0.3.tgz" + integrity sha512-I6Heg70nfF+e5Y3/qfthJFexhRw/Gi3bIymCoXAlijZdAcLaPuWSJs3KXyTYf23ID6g0o2QF62Yh+grOXY3Rig== + dependencies: + inherits "^2.0.1" + readable-stream "^2.0.5" + xtend "^4.0.0" + +level-iterator-stream@~1.3.0: + version "1.3.1" + resolved "https://registry.npmjs.org/level-iterator-stream/-/level-iterator-stream-1.3.1.tgz" + integrity sha1-5Dt4sagUPm+pek9IXrjqUwNS8u0= + dependencies: + inherits "^2.0.1" + level-errors "^1.0.3" + readable-stream "^1.0.33" + xtend "^4.0.0" + +level-iterator-stream@~3.0.0: + version "3.0.1" + resolved "https://registry.npmjs.org/level-iterator-stream/-/level-iterator-stream-3.0.1.tgz" + integrity sha512-nEIQvxEED9yRThxvOrq8Aqziy4EGzrxSZK+QzEFAVuJvQ8glfyZ96GB6BoI4sBbLfjMXm2w4vu3Tkcm9obcY0g== + dependencies: + inherits "^2.0.1" + readable-stream "^2.3.6" + xtend "^4.0.0" + +level-iterator-stream@~4.0.0: + version "4.0.2" + resolved "https://registry.npmjs.org/level-iterator-stream/-/level-iterator-stream-4.0.2.tgz" + integrity sha512-ZSthfEqzGSOMWoUGhTXdX9jv26d32XJuHz/5YnuHZzH6wldfWMOVwI9TBtKcya4BKTyTt3XVA0A3cF3q5CY30Q== + dependencies: + inherits "^2.0.4" + readable-stream "^3.4.0" + xtend "^4.0.2" + +level-mem@^3.0.1: + version "3.0.1" + resolved "https://registry.npmjs.org/level-mem/-/level-mem-3.0.1.tgz" + integrity sha512-LbtfK9+3Ug1UmvvhR2DqLqXiPW1OJ5jEh0a3m9ZgAipiwpSxGj/qaVVy54RG5vAQN1nCuXqjvprCuKSCxcJHBg== + dependencies: + level-packager "~4.0.0" + memdown "~3.0.0" + +level-mem@^5.0.1: + version "5.0.1" + resolved "https://registry.npmjs.org/level-mem/-/level-mem-5.0.1.tgz" + integrity sha512-qd+qUJHXsGSFoHTziptAKXoLX87QjR7v2KMbqncDXPxQuCdsQlzmyX+gwrEHhlzn08vkf8TyipYyMmiC6Gobzg== + dependencies: + level-packager "^5.0.3" + memdown "^5.0.0" + +level-packager@^5.0.3: + version "5.1.1" + resolved "https://registry.npmjs.org/level-packager/-/level-packager-5.1.1.tgz" + integrity sha512-HMwMaQPlTC1IlcwT3+swhqf/NUO+ZhXVz6TY1zZIIZlIR0YSn8GtAAWmIvKjNY16ZkEg/JcpAuQskxsXqC0yOQ== + dependencies: + encoding-down "^6.3.0" + levelup "^4.3.2" + +level-packager@~4.0.0: + version "4.0.1" + resolved "https://registry.npmjs.org/level-packager/-/level-packager-4.0.1.tgz" + integrity sha512-svCRKfYLn9/4CoFfi+d8krOtrp6RoX8+xm0Na5cgXMqSyRru0AnDYdLl+YI8u1FyS6gGZ94ILLZDE5dh2but3Q== + dependencies: + encoding-down "~5.0.0" + levelup "^3.0.0" + +level-post@^1.0.7: + version "1.0.7" + resolved "https://registry.npmjs.org/level-post/-/level-post-1.0.7.tgz" + integrity sha512-PWYqG4Q00asOrLhX7BejSajByB4EmG2GaKHfj3h5UmmZ2duciXLPGYWIjBzLECFWUGOZWlm5B20h/n3Gs3HKew== + dependencies: + ltgt "^2.1.2" + +level-sublevel@6.6.4: + version "6.6.4" + resolved "https://registry.npmjs.org/level-sublevel/-/level-sublevel-6.6.4.tgz" + integrity sha512-pcCrTUOiO48+Kp6F1+UAzF/OtWqLcQVTVF39HLdZ3RO8XBoXt+XVPKZO1vVr1aUoxHZA9OtD2e1v7G+3S5KFDA== + dependencies: + bytewise "~1.1.0" + level-codec "^9.0.0" + level-errors "^2.0.0" + level-iterator-stream "^2.0.3" + ltgt "~2.1.1" + pull-defer "^0.2.2" + pull-level "^2.0.3" + pull-stream "^3.6.8" + typewiselite "~1.0.0" + xtend "~4.0.0" + +level-supports@~1.0.0: + version "1.0.1" + resolved "https://registry.npmjs.org/level-supports/-/level-supports-1.0.1.tgz" + integrity sha512-rXM7GYnW8gsl1vedTJIbzOrRv85c/2uCMpiiCzO2fndd06U/kUXEEU9evYn4zFggBOg36IsBW8LzqIpETwwQzg== + dependencies: + xtend "^4.0.2" + +level-ws@0.0.0: + version "0.0.0" + resolved "https://registry.npmjs.org/level-ws/-/level-ws-0.0.0.tgz" + integrity sha1-Ny5RIXeSSgBCSwtDrvK7QkltIos= + dependencies: + readable-stream "~1.0.15" + xtend "~2.1.1" + +level-ws@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/level-ws/-/level-ws-1.0.0.tgz" + integrity sha512-RXEfCmkd6WWFlArh3X8ONvQPm8jNpfA0s/36M4QzLqrLEIt1iJE9WBHLZ5vZJK6haMjJPJGJCQWfjMNnRcq/9Q== + dependencies: + inherits "^2.0.3" + readable-stream "^2.2.8" + xtend "^4.0.1" + +level-ws@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/level-ws/-/level-ws-2.0.0.tgz" + integrity sha512-1iv7VXx0G9ec1isqQZ7y5LmoZo/ewAsyDHNA8EFDW5hqH2Kqovm33nSFkSdnLLAK+I5FlT+lo5Cw9itGe+CpQA== + dependencies: + inherits "^2.0.3" + readable-stream "^3.1.0" + xtend "^4.0.1" + +levelup@3.1.1, levelup@^3.0.0: + version "3.1.1" + resolved "https://registry.npmjs.org/levelup/-/levelup-3.1.1.tgz" + integrity sha512-9N10xRkUU4dShSRRFTBdNaBxofz+PGaIZO962ckboJZiNmLuhVT6FZ6ZKAsICKfUBO76ySaYU6fJWX/jnj3Lcg== + dependencies: + deferred-leveldown "~4.0.0" + level-errors "~2.0.0" + level-iterator-stream "~3.0.0" + xtend "~4.0.0" + +levelup@^1.2.1: + version "1.3.9" + resolved "https://registry.npmjs.org/levelup/-/levelup-1.3.9.tgz" + integrity sha512-VVGHfKIlmw8w1XqpGOAGwq6sZm2WwWLmlDcULkKWQXEA5EopA8OBNJ2Ck2v6bdk8HeEZSbCSEgzXadyQFm76sQ== + dependencies: + deferred-leveldown "~1.2.1" + level-codec "~7.0.0" + level-errors "~1.0.3" + level-iterator-stream "~1.3.0" + prr "~1.0.1" + semver "~5.4.1" + xtend "~4.0.0" + +levelup@^4.3.2: + version "4.4.0" + resolved "https://registry.npmjs.org/levelup/-/levelup-4.4.0.tgz" + integrity sha512-94++VFO3qN95cM/d6eBXvd894oJE0w3cInq9USsyQzzoJxmiYzPAocNcuGCPGGjoXqDVJcr3C1jzt1TSjyaiLQ== + dependencies: + deferred-leveldown "~5.3.0" + level-errors "~2.0.0" + level-iterator-stream "~4.0.0" + level-supports "~1.0.0" + xtend "~4.0.0" + +levn@^0.3.0, levn@~0.3.0: + version "0.3.0" + resolved "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz" + integrity sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4= + dependencies: + prelude-ls "~1.1.2" + type-check "~0.3.2" + +levn@^0.4.1: + version "0.4.1" + resolved "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz" + integrity sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ== + dependencies: + prelude-ls "^1.2.1" + type-check "~0.4.0" + +lilconfig@2.0.4: + version "2.0.4" + resolved "https://registry.npmjs.org/lilconfig/-/lilconfig-2.0.4.tgz" + integrity sha512-bfTIN7lEsiooCocSISTWXkiWJkRqtL9wYtYy+8EK3Y41qh3mpwPU0ycTOgjdY9ErwXCc8QyrQp82bdL0Xkm9yA== + +lint-staged@>=10: + version "12.4.1" + resolved "https://registry.npmjs.org/lint-staged/-/lint-staged-12.4.1.tgz" + integrity sha512-PTXgzpflrQ+pODQTG116QNB+Q6uUTDg5B5HqGvNhoQSGt8Qy+MA/6zSnR8n38+sxP5TapzeQGTvoKni0KRS8Vg== + dependencies: + cli-truncate "^3.1.0" + colorette "^2.0.16" + commander "^8.3.0" + debug "^4.3.3" + execa "^5.1.1" + lilconfig "2.0.4" + listr2 "^4.0.1" + micromatch "^4.0.4" + normalize-path "^3.0.0" + object-inspect "^1.12.0" + pidtree "^0.5.0" + string-argv "^0.3.1" + supports-color "^9.2.1" + yaml "^1.10.2" + +listr2@^4.0.1: + version "4.0.5" + resolved "https://registry.npmjs.org/listr2/-/listr2-4.0.5.tgz" + integrity sha512-juGHV1doQdpNT3GSTs9IUN43QJb7KHdF9uqg7Vufs/tG9VTzpFphqF4pm/ICdAABGQxsyNn9CiYA3StkI6jpwA== + dependencies: + cli-truncate "^2.1.0" + colorette "^2.0.16" + log-update "^4.0.0" + p-map "^4.0.0" + rfdc "^1.3.0" + rxjs "^7.5.5" + through "^2.3.8" + wrap-ansi "^7.0.0" + +load-json-file@^1.0.0: + version "1.1.0" + resolved "https://registry.npmjs.org/load-json-file/-/load-json-file-1.1.0.tgz" + integrity sha1-lWkFcI1YtLq0wiYbBPWfMcmTdMA= + dependencies: + graceful-fs "^4.1.2" + parse-json "^2.2.0" + pify "^2.0.0" + pinkie-promise "^2.0.0" + strip-bom "^2.0.0" + +locate-path@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/locate-path/-/locate-path-2.0.0.tgz" + integrity sha1-K1aLJl7slExtnA3pw9u7ygNUzY4= + dependencies: + p-locate "^2.0.0" + path-exists "^3.0.0" + +locate-path@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/locate-path/-/locate-path-3.0.0.tgz" + integrity sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A== + dependencies: + p-locate "^3.0.0" + path-exists "^3.0.0" + +locate-path@^6.0.0: + version "6.0.0" + resolved "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz" + integrity sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw== + dependencies: + p-locate "^5.0.0" + +lodash.assign@^4.0.3: + version "4.2.0" + resolved "https://registry.npmjs.org/lodash.assign/-/lodash.assign-4.2.0.tgz" + integrity sha1-DZnzzNem0mHRm9rrkkUAXShYCOc= + +lodash.camelcase@^4.3.0: + version "4.3.0" + resolved "https://registry.npmjs.org/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz" + integrity sha1-soqmKIorn8ZRA1x3EfZathkDMaY= + +lodash.merge@^4.6.2: + version "4.6.2" + resolved "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz" + integrity sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ== + +lodash.truncate@^4.4.2: + version "4.4.2" + resolved "https://registry.yarnpkg.com/lodash.truncate/-/lodash.truncate-4.4.2.tgz#5a350da0b1113b837ecfffd5812cbe58d6eae193" + integrity sha512-jttmRe7bRse52OsWIMDLaXxWqRAmtIUccAQ3garviCqJjafXOfNMO0yMfNpdD6zbGaTU0P5Nz7e7gAT6cKmJRw== + +lodash@4.17.20, lodash@>=4.17.21, lodash@^4.17.11, lodash@^4.17.12, lodash@^4.17.14, lodash@^4.17.15, lodash@^4.17.19, lodash@^4.17.21, lodash@^4.17.4: + version "4.17.21" + resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c" + integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg== + +log-symbols@3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/log-symbols/-/log-symbols-3.0.0.tgz" + integrity sha512-dSkNGuI7iG3mfvDzUuYZyvk5dD9ocYCYzNU6CYDE6+Xqd+gwme6Z00NS3dUh8mq/73HaEtT7m6W+yUPtU6BZnQ== + dependencies: + chalk "^2.4.2" + +log-symbols@4.1.0: + version "4.1.0" + resolved "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz" + integrity sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg== + dependencies: + chalk "^4.1.0" + is-unicode-supported "^0.1.0" + +log-update@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/log-update/-/log-update-4.0.0.tgz" + integrity sha512-9fkkDevMefjg0mmzWFBW8YkFP91OrizzkW3diF7CpG+S2EYdy4+TVfGwz1zeF8x7hCx1ovSPTOE9Ngib74qqUg== + dependencies: + ansi-escapes "^4.3.0" + cli-cursor "^3.1.0" + slice-ansi "^4.0.0" + wrap-ansi "^6.2.0" + +looper@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/looper/-/looper-2.0.0.tgz" + integrity sha1-Zs0Md0rz1P7axTeU90LbVtqPCew= + +looper@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/looper/-/looper-3.0.0.tgz" + integrity sha1-LvpUw7HLq6m5Su4uWRSwvlf7t0k= + +loose-envify@^1.0.0: + version "1.4.0" + resolved "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz" + integrity sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q== + dependencies: + js-tokens "^3.0.0 || ^4.0.0" + +loupe@^2.3.1: + version "2.3.4" + resolved "https://registry.npmjs.org/loupe/-/loupe-2.3.4.tgz" + integrity sha512-OvKfgCC2Ndby6aSTREl5aCCPTNIzlDfQZvZxNUrBrihDhL3xcrYegTblhmEiCrg2kKQz4XsFIaemE5BF4ybSaQ== + dependencies: + get-func-name "^2.0.0" + +lowercase-keys@^1.0.0, lowercase-keys@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-1.0.1.tgz" + integrity sha512-G2Lj61tXDnVFFOi8VZds+SoQjtQC3dgokKdDG2mTm1tx4m50NUHBOZSBwQQHyy0V12A0JTG4icfZQH+xPyh8VA== + +lowercase-keys@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-2.0.0.tgz" + integrity sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA== + +lru-cache@5.1.1, lru-cache@^5.1.1: + version "5.1.1" + resolved "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz" + integrity sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w== + dependencies: + yallist "^3.0.2" + +lru-cache@^3.2.0: + version "3.2.0" + resolved "https://registry.npmjs.org/lru-cache/-/lru-cache-3.2.0.tgz" + integrity sha1-cXibO39Tmb7IVl3aOKow0qCX7+4= + dependencies: + pseudomap "^1.0.1" + +lru-cache@^6.0.0: + version "6.0.0" + resolved "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz" + integrity sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA== + dependencies: + yallist "^4.0.0" + +lru_map@^0.3.3: + version "0.3.3" + resolved "https://registry.npmjs.org/lru_map/-/lru_map-0.3.3.tgz" + integrity sha1-tcg1G5Rky9dQM1p5ZQoOwOVhGN0= + +ltgt@^2.1.2, ltgt@~2.1.1: + version "2.1.3" + resolved "https://registry.npmjs.org/ltgt/-/ltgt-2.1.3.tgz" + integrity sha1-EIUaBtmWS5cReEQcI8nlJpjuzjQ= + +ltgt@~2.2.0: + version "2.2.1" + resolved "https://registry.npmjs.org/ltgt/-/ltgt-2.2.1.tgz" + integrity sha1-81ypHEk/e3PaDgdJUwTxezH4fuU= + +make-error@^1.1.1: + version "1.3.6" + resolved "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz" + integrity sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw== + +map-cache@^0.2.2: + version "0.2.2" + resolved "https://registry.npmjs.org/map-cache/-/map-cache-0.2.2.tgz" + integrity sha1-wyq9C9ZSXZsFFkW7TyasXcmKDb8= + +map-visit@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/map-visit/-/map-visit-1.0.0.tgz" + integrity sha1-7Nyo8TFE5mDxtb1B8S80edmN+48= + dependencies: + object-visit "^1.0.0" + +markdown-table@^1.1.3: + version "1.1.3" + resolved "https://registry.npmjs.org/markdown-table/-/markdown-table-1.1.3.tgz" + integrity sha512-1RUZVgQlpJSPWYbFSpmudq5nHY1doEIv89gBtF0s4gW1GF2XorxcA/70M5vq7rLv0a6mhOUccRsqkwhwLCIQ2Q== + +match-all@^1.2.6: + version "1.2.6" + resolved "https://registry.yarnpkg.com/match-all/-/match-all-1.2.6.tgz#66d276ad6b49655551e63d3a6ee53e8be0566f8d" + integrity sha512-0EESkXiTkWzrQQntBu2uzKvLu6vVkUGz40nGPbSZuegcfE5UuSzNjLaIu76zJWuaT/2I3Z/8M06OlUOZLGwLlQ== + +mcl-wasm@^0.7.1: + version "0.7.9" + resolved "https://registry.npmjs.org/mcl-wasm/-/mcl-wasm-0.7.9.tgz" + integrity sha512-iJIUcQWA88IJB/5L15GnJVnSQJmf/YaxxV6zRavv83HILHaJQb6y0iFyDMdDO0gN8X37tdxmAOrH/P8B6RB8sQ== + +md5.js@^1.3.4: + version "1.3.5" + resolved "https://registry.npmjs.org/md5.js/-/md5.js-1.3.5.tgz" + integrity sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg== + dependencies: + hash-base "^3.0.0" + inherits "^2.0.1" + safe-buffer "^5.1.2" + +media-typer@0.3.0: + version "0.3.0" + resolved "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz" + integrity sha1-hxDXrwqmJvj/+hzgAWhUUmMlV0g= + +memdown@^1.0.0: + version "1.4.1" + resolved "https://registry.npmjs.org/memdown/-/memdown-1.4.1.tgz" + integrity sha1-tOThkhdGZP+65BNhqlAPMRnv4hU= + dependencies: + abstract-leveldown "~2.7.1" + functional-red-black-tree "^1.0.1" + immediate "^3.2.3" + inherits "~2.0.1" + ltgt "~2.2.0" + safe-buffer "~5.1.1" + +memdown@^5.0.0: + version "5.1.0" + resolved "https://registry.npmjs.org/memdown/-/memdown-5.1.0.tgz" + integrity sha512-B3J+UizMRAlEArDjWHTMmadet+UKwHd3UjMgGBkZcKAxAYVPS9o0Yeiha4qvz7iGiL2Sb3igUft6p7nbFWctpw== + dependencies: + abstract-leveldown "~6.2.1" + functional-red-black-tree "~1.0.1" + immediate "~3.2.3" + inherits "~2.0.1" + ltgt "~2.2.0" + safe-buffer "~5.2.0" + +memdown@~3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/memdown/-/memdown-3.0.0.tgz" + integrity sha512-tbV02LfZMWLcHcq4tw++NuqMO+FZX8tNJEiD2aNRm48ZZusVg5N8NART+dmBkepJVye986oixErf7jfXboMGMA== + dependencies: + abstract-leveldown "~5.0.0" + functional-red-black-tree "~1.0.1" + immediate "~3.2.3" + inherits "~2.0.1" + ltgt "~2.2.0" + safe-buffer "~5.1.1" + +memorystream@^0.3.1: + version "0.3.1" + resolved "https://registry.npmjs.org/memorystream/-/memorystream-0.3.1.tgz" + integrity sha1-htcJCzDORV1j+64S3aUaR93K+bI= + +merge-descriptors@1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.1.tgz" + integrity sha1-sAqqVW3YtEVoFQ7J0blT8/kMu2E= + +merge-stream@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz" + integrity sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w== + +merge2@^1.2.3, merge2@^1.3.0, merge2@^1.4.1: + version "1.4.1" + resolved "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz" + integrity sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg== + +merkle-patricia-tree@3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/merkle-patricia-tree/-/merkle-patricia-tree-3.0.0.tgz" + integrity sha512-soRaMuNf/ILmw3KWbybaCjhx86EYeBbD8ph0edQCTed0JN/rxDt1EBN52Ajre3VyGo+91f8+/rfPIRQnnGMqmQ== + dependencies: + async "^2.6.1" + ethereumjs-util "^5.2.0" + level-mem "^3.0.1" + level-ws "^1.0.0" + readable-stream "^3.0.6" + rlp "^2.0.0" + semaphore ">=1.0.1" + +merkle-patricia-tree@^2.1.2, merkle-patricia-tree@^2.3.2: + version "2.3.2" + resolved "https://registry.npmjs.org/merkle-patricia-tree/-/merkle-patricia-tree-2.3.2.tgz" + integrity sha512-81PW5m8oz/pz3GvsAwbauj7Y00rqm81Tzad77tHBwU7pIAtN+TJnMSOJhxBKflSVYhptMMb9RskhqHqrSm1V+g== + dependencies: + async "^1.4.2" + ethereumjs-util "^5.0.0" + level-ws "0.0.0" + levelup "^1.2.1" + memdown "^1.0.0" + readable-stream "^2.0.0" + rlp "^2.0.0" + semaphore ">=1.0.1" + +merkle-patricia-tree@^4.2.2, merkle-patricia-tree@^4.2.4: + version "4.2.4" + resolved "https://registry.npmjs.org/merkle-patricia-tree/-/merkle-patricia-tree-4.2.4.tgz" + integrity sha512-eHbf/BG6eGNsqqfbLED9rIqbsF4+sykEaBn6OLNs71tjclbMcMOk1tEPmJKcNcNCLkvbpY/lwyOlizWsqPNo8w== + dependencies: + "@types/levelup" "^4.3.0" + ethereumjs-util "^7.1.4" + level-mem "^5.0.1" + level-ws "^2.0.0" + readable-stream "^3.6.0" + semaphore-async-await "^1.5.1" + +methods@~1.1.2: + version "1.1.2" + resolved "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz" + integrity sha1-VSmk1nZUE07cxSZmVoNbD4Ua/O4= + +micromatch@^3.1.4: + version "3.1.10" + resolved "https://registry.npmjs.org/micromatch/-/micromatch-3.1.10.tgz" + integrity sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg== + dependencies: + arr-diff "^4.0.0" + array-unique "^0.3.2" + braces "^2.3.1" + define-property "^2.0.2" + extend-shallow "^3.0.2" + extglob "^2.0.4" + fragment-cache "^0.2.1" + kind-of "^6.0.2" + nanomatch "^1.2.9" + object.pick "^1.3.0" + regex-not "^1.0.0" + snapdragon "^0.8.1" + to-regex "^3.0.2" + +micromatch@^4.0.2, micromatch@^4.0.4: + version "4.0.5" + resolved "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz" + integrity sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA== + dependencies: + braces "^3.0.2" + picomatch "^2.3.1" + +miller-rabin@^4.0.0: + version "4.0.1" + resolved "https://registry.npmjs.org/miller-rabin/-/miller-rabin-4.0.1.tgz" + integrity sha512-115fLhvZVqWwHPbClyntxEVfVDfl9DLLTuJvq3g2O/Oxi8AiNouAHvDSzHS0viUJc+V5vm3eq91Xwqn9dp4jRA== + dependencies: + bn.js "^4.0.0" + brorand "^1.0.1" + +mime-db@1.52.0: + version "1.52.0" + resolved "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz" + integrity sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg== + +mime-types@^2.1.12, mime-types@^2.1.16, mime-types@~2.1.19, mime-types@~2.1.24, mime-types@~2.1.34: + version "2.1.35" + resolved "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz" + integrity sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw== + dependencies: + mime-db "1.52.0" + +mime@1.6.0: + version "1.6.0" + resolved "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz" + integrity sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg== + +mimic-fn@^1.0.0: + version "1.2.0" + resolved "https://registry.npmjs.org/mimic-fn/-/mimic-fn-1.2.0.tgz" + integrity sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ== + +mimic-fn@^2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz" + integrity sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg== + +mimic-response@^1.0.0, mimic-response@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/mimic-response/-/mimic-response-1.0.1.tgz" + integrity sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ== + +min-document@^2.19.0: + version "2.19.0" + resolved "https://registry.npmjs.org/min-document/-/min-document-2.19.0.tgz" + integrity sha1-e9KC4/WELtKVu3SM3Z8f+iyCRoU= + dependencies: + dom-walk "^0.1.0" + +minimalistic-assert@^1.0.0, minimalistic-assert@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz" + integrity sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A== + +minimalistic-crypto-utils@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz" + integrity sha1-9sAMHAsIIkblxNmd+4x8CDsrWCo= + +"minimatch@2 || 3", minimatch@^3.0.4, minimatch@^3.1.2: + version "3.1.2" + resolved "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz" + integrity sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw== + dependencies: + brace-expansion "^1.1.7" + +minimatch@3.0.4: + version "3.0.4" + resolved "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz" + integrity sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA== + dependencies: + brace-expansion "^1.1.7" + +minimatch@4.2.1: + version "4.2.1" + resolved "https://registry.npmjs.org/minimatch/-/minimatch-4.2.1.tgz" + integrity sha512-9Uq1ChtSZO+Mxa/CL1eGizn2vRn3MlLgzhT0Iz8zaY8NdvxvB0d5QdPFmCKf7JKA9Lerx5vRrnwO03jsSfGG9g== + dependencies: + brace-expansion "^1.1.7" + +minimist@^1.2.0, minimist@^1.2.5, minimist@^1.2.6, minimist@~1.2.6: + version "1.2.6" + resolved "https://registry.npmjs.org/minimist/-/minimist-1.2.6.tgz" + integrity sha512-Jsjnk4bw3YJqYzbdyBiNsPWHPfO++UGG749Cxs6peCu5Xg4nrena6OVxOYxrQTqww0Jmwt+Ref8rggumkTLz9Q== + +minipass@^2.6.0, minipass@^2.9.0: + version "2.9.0" + resolved "https://registry.npmjs.org/minipass/-/minipass-2.9.0.tgz" + integrity sha512-wxfUjg9WebH+CUDX/CdbRlh5SmfZiy/hpkxaRI16Y9W56Pa75sWgd/rvFilSgrauD9NyFymP/+JFV3KwzIsJeg== + dependencies: + safe-buffer "^5.1.2" + yallist "^3.0.0" + +minizlib@^1.3.3: + version "1.3.3" + resolved "https://registry.npmjs.org/minizlib/-/minizlib-1.3.3.tgz" + integrity sha512-6ZYMOEnmVsdCeTJVE0W9ZD+pVnE8h9Hma/iOwwRDsdQoePpoX56/8B6z3P9VNwppJuBKNRuFDRNRqRWexT9G9Q== + dependencies: + minipass "^2.9.0" + +mixin-deep@^1.2.0: + version "1.3.2" + resolved "https://registry.npmjs.org/mixin-deep/-/mixin-deep-1.3.2.tgz" + integrity sha512-WRoDn//mXBiJ1H40rqa3vH0toePwSsGb45iInWlTySa+Uu4k3tYUSxa2v1KqAiLtvlrSzaExqS1gtk96A9zvEA== + dependencies: + for-in "^1.0.2" + is-extendable "^1.0.1" + +mkdirp-promise@^5.0.1: + version "5.0.1" + resolved "https://registry.npmjs.org/mkdirp-promise/-/mkdirp-promise-5.0.1.tgz" + integrity sha1-6bj2jlUsaKnBcTuEiD96HdA5uKE= + dependencies: + mkdirp "*" + +mkdirp@*, mkdirp@^1.0.4: + version "1.0.4" + resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-1.0.4.tgz#3eb5ed62622756d79a5f0e2a221dfebad75c2f7e" + integrity sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw== + +mkdirp@0.5.5: + version "0.5.5" + resolved "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.5.tgz" + integrity sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ== + dependencies: + minimist "^1.2.5" + +mkdirp@0.5.x, mkdirp@^0.5.1, mkdirp@^0.5.5: + version "0.5.6" + resolved "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.6.tgz" + integrity sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw== + dependencies: + minimist "^1.2.6" + +mnemonist@^0.38.0: + version "0.38.5" + resolved "https://registry.npmjs.org/mnemonist/-/mnemonist-0.38.5.tgz" + integrity sha512-bZTFT5rrPKtPJxj8KSV0WkPyNxl72vQepqqVUAW2ARUpUSF2qXMB6jZj7hW5/k7C1rtpzqbD/IIbJwLXUjCHeg== + dependencies: + obliterator "^2.0.0" + +mocha@^7.1.1: + version "7.2.0" + resolved "https://registry.npmjs.org/mocha/-/mocha-7.2.0.tgz" + integrity sha512-O9CIypScywTVpNaRrCAgoUnJgozpIofjKUYmJhiCIJMiuYnLI6otcb1/kpW9/n/tJODHGZ7i8aLQoDVsMtOKQQ== + dependencies: + ansi-colors "3.2.3" + browser-stdout "1.3.1" + chokidar "3.3.0" + debug "3.2.6" + diff "3.5.0" + escape-string-regexp "1.0.5" + find-up "3.0.0" + glob "7.1.3" + growl "1.10.5" + he "1.2.0" + js-yaml "3.13.1" + log-symbols "3.0.0" + minimatch "3.0.4" + mkdirp "0.5.5" + ms "2.1.1" + node-environment-flags "1.0.6" + object.assign "4.1.0" + strip-json-comments "2.0.1" + supports-color "6.0.0" + which "1.3.1" + wide-align "1.1.3" + yargs "13.3.2" + yargs-parser "13.1.2" + yargs-unparser "1.6.0" + +mocha@^9.2.0: + version "9.2.2" + resolved "https://registry.npmjs.org/mocha/-/mocha-9.2.2.tgz" + integrity sha512-L6XC3EdwT6YrIk0yXpavvLkn8h+EU+Y5UcCHKECyMbdUIxyMuZj4bX4U9e1nvnvUUvQVsV2VHQr5zLdcUkhW/g== + dependencies: + "@ungap/promise-all-settled" "1.1.2" + ansi-colors "4.1.1" + browser-stdout "1.3.1" + chokidar "3.5.3" + debug "4.3.3" + diff "5.0.0" + escape-string-regexp "4.0.0" + find-up "5.0.0" + glob "7.2.0" + growl "1.10.5" + he "1.2.0" + js-yaml "4.1.0" + log-symbols "4.1.0" + minimatch "4.2.1" + ms "2.1.3" + nanoid "3.3.1" + serialize-javascript "6.0.0" + strip-json-comments "3.1.1" + supports-color "8.1.1" + which "2.0.2" + workerpool "6.2.0" + yargs "16.2.0" + yargs-parser "20.2.4" + yargs-unparser "2.0.0" + +mock-fs@^4.1.0: + version "4.14.0" + resolved "https://registry.npmjs.org/mock-fs/-/mock-fs-4.14.0.tgz" + integrity sha512-qYvlv/exQ4+svI3UOvPUpLDF0OMX5euvUH0Ny4N5QyRyhNdgAgUrVH3iUINSzEPLvx0kbo/Bp28GJKIqvE7URw== + +ms@2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz" + integrity sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g= + +ms@2.1.1: + version "2.1.1" + resolved "https://registry.npmjs.org/ms/-/ms-2.1.1.tgz" + integrity sha512-tgp+dl5cGk28utYktBsrFqA7HKgrhgPsg6Z/EfhWI4gl1Hwq8B/GmY/0oXZ6nF8hDVesS/FpnYaD/kOWhYQvyg== + +ms@2.1.2: + version "2.1.2" + resolved "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz" + integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w== + +ms@2.1.3, ms@^2.1.1: + version "2.1.3" + resolved "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz" + integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA== + +multibase@^0.7.0: + version "0.7.0" + resolved "https://registry.npmjs.org/multibase/-/multibase-0.7.0.tgz" + integrity sha512-TW8q03O0f6PNFTQDvh3xxH03c8CjGaaYrjkl9UQPG6rz53TQzzxJVCIWVjzcbN/Q5Y53Zd0IBQBMVktVgNx4Fg== + dependencies: + base-x "^3.0.8" + buffer "^5.5.0" + +multibase@~0.6.0: + version "0.6.1" + resolved "https://registry.npmjs.org/multibase/-/multibase-0.6.1.tgz" + integrity sha512-pFfAwyTjbbQgNc3G7D48JkJxWtoJoBMaR4xQUOuB8RnCgRqaYmWNFeJTTvrJ2w51bjLq2zTby6Rqj9TQ9elSUw== + dependencies: + base-x "^3.0.8" + buffer "^5.5.0" + +multicodec@^0.5.5: + version "0.5.7" + resolved "https://registry.npmjs.org/multicodec/-/multicodec-0.5.7.tgz" + integrity sha512-PscoRxm3f+88fAtELwUnZxGDkduE2HD9Q6GHUOywQLjOGT/HAdhjLDYNZ1e7VR0s0TP0EwZ16LNUTFpoBGivOA== + dependencies: + varint "^5.0.0" + +multicodec@^1.0.0: + version "1.0.4" + resolved "https://registry.npmjs.org/multicodec/-/multicodec-1.0.4.tgz" + integrity sha512-NDd7FeS3QamVtbgfvu5h7fd1IlbaC4EQ0/pgU4zqE2vdHCmBGsUa0TiM8/TdSeG6BMPC92OOCf8F1ocE/Wkrrg== + dependencies: + buffer "^5.6.0" + varint "^5.0.0" + +multihashes@^0.4.15, multihashes@~0.4.15: + version "0.4.21" + resolved "https://registry.npmjs.org/multihashes/-/multihashes-0.4.21.tgz" + integrity sha512-uVSvmeCWf36pU2nB4/1kzYZjsXD9vofZKpgudqkceYY5g2aZZXJ5r9lxuzoRLl1OAp28XljXsEJ/X/85ZsKmKw== + dependencies: + buffer "^5.5.0" + multibase "^0.7.0" + varint "^5.0.0" + +murmur-128@^0.2.1: + version "0.2.1" + resolved "https://registry.yarnpkg.com/murmur-128/-/murmur-128-0.2.1.tgz#a9f6568781d2350ecb1bf80c14968cadbeaa4b4d" + integrity sha512-WseEgiRkI6aMFBbj8Cg9yBj/y+OdipwVC7zUo3W2W1JAJITwouUOtpqsmGSg67EQmwwSyod7hsVsWY5LsrfQVg== + dependencies: + encode-utf8 "^1.0.2" + fmix "^0.1.0" + imul "^1.0.0" + +mute-stream@0.0.7: + version "0.0.7" + resolved "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.7.tgz" + integrity sha1-MHXOk7whuPq0PhvE2n6BFe0ee6s= + +nano-json-stream-parser@^0.1.2: + version "0.1.2" + resolved "https://registry.npmjs.org/nano-json-stream-parser/-/nano-json-stream-parser-0.1.2.tgz" + integrity sha1-DMj20OK2IrR5xA1JnEbWS3Vcb18= + +nanoid@3.3.1: + version "3.3.1" + resolved "https://registry.npmjs.org/nanoid/-/nanoid-3.3.1.tgz" + integrity sha512-n6Vs/3KGyxPQd6uO0eH4Bv0ojGSUvuLlIHtC3Y0kEO23YRge8H9x1GCzLn28YX0H66pMkxuaeESFq4tKISKwdw== + +nanomatch@^1.2.9: + version "1.2.13" + resolved "https://registry.npmjs.org/nanomatch/-/nanomatch-1.2.13.tgz" + integrity sha512-fpoe2T0RbHwBTBUOftAfBPaDEi06ufaUai0mE6Yn1kacc3SnTErfb/h+X94VXzI64rKFHYImXSvdwGGCmwOqCA== + dependencies: + arr-diff "^4.0.0" + array-unique "^0.3.2" + define-property "^2.0.2" + extend-shallow "^3.0.2" + fragment-cache "^0.2.1" + is-windows "^1.0.2" + kind-of "^6.0.2" + object.pick "^1.3.0" + regex-not "^1.0.0" + snapdragon "^0.8.1" + to-regex "^3.0.1" + +natural-compare@^1.4.0: + version "1.4.0" + resolved "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz" + integrity sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc= + +negotiator@0.6.3: + version "0.6.3" + resolved "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz" + integrity sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg== + +neo-async@^2.6.0: + version "2.6.2" + resolved "https://registry.npmjs.org/neo-async/-/neo-async-2.6.2.tgz" + integrity sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw== + +next-tick@^1.1.0: + version "1.1.0" + resolved "https://registry.npmjs.org/next-tick/-/next-tick-1.1.0.tgz" + integrity sha512-CXdUiJembsNjuToQvxayPZF9Vqht7hewsvy2sOWafLvi2awflj9mOC6bHIg50orX8IJvWKY9wYQ/zB2kogPslQ== + +nice-try@^1.0.4: + version "1.0.5" + resolved "https://registry.npmjs.org/nice-try/-/nice-try-1.0.5.tgz" + integrity sha512-1nh45deeb5olNY7eX82BkPO7SSxR5SSYJiPTrTdFUVYwAl8CKMA5N9PjTYkHiRjisVcxcQ1HXdLhx2qxxJzLNQ== + +node-addon-api@^2.0.0: + version "2.0.2" + resolved "https://registry.npmjs.org/node-addon-api/-/node-addon-api-2.0.2.tgz" + integrity sha512-Ntyt4AIXyaLIuMHF6IOoTakB3K+RWxwtsHNRxllEoA6vPwP9o4866g6YWDLUdnucilZhmkxiHwHr11gAENw+QA== + +node-domexception@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/node-domexception/-/node-domexception-1.0.0.tgz" + integrity sha512-/jKZoMpw0F8GRwl4/eLROPA3cfcXtLApP0QzLmUT/HuPCZWyB7IY9ZrMeKw2O/nFIqPQB3PVM9aYm0F312AXDQ== + +node-emoji@^1.10.0: + version "1.11.0" + resolved "https://registry.npmjs.org/node-emoji/-/node-emoji-1.11.0.tgz" + integrity sha512-wo2DpQkQp7Sjm2A0cq+sN7EHKO6Sl0ctXeBdFZrL9T9+UywORbufTcTZxom8YqpLQt/FqNMUkOpkZrJVYSKD3A== + dependencies: + lodash "^4.17.21" + +node-environment-flags@1.0.6: + version "1.0.6" + resolved "https://registry.npmjs.org/node-environment-flags/-/node-environment-flags-1.0.6.tgz" + integrity sha512-5Evy2epuL+6TM0lCQGpFIj6KwiEsGh1SrHUhTbNX+sLbBtjidPZFAnVK9y5yU1+h//RitLbRHTIMyxQPtxMdHw== + dependencies: + object.getownpropertydescriptors "^2.0.3" + semver "^5.7.0" + +node-fetch@2.6.7, node-fetch@>=2.6.7, node-fetch@^2.6.1, node-fetch@~1.7.1: + version "3.2.4" + resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-3.2.4.tgz#3fbca2d8838111048232de54cb532bd3cf134947" + integrity sha512-WvYJRN7mMyOLurFR2YpysQGuwYrJN+qrrpHjJDuKMcSPdfFccRUla/kng2mz6HWSBxJcqPbvatS6Gb4RhOzCJw== + dependencies: + data-uri-to-buffer "^4.0.0" + fetch-blob "^3.1.4" + formdata-polyfill "^4.0.10" + +node-gyp-build@^4.2.0, node-gyp-build@^4.3.0: + version "4.4.0" + resolved "https://registry.npmjs.org/node-gyp-build/-/node-gyp-build-4.4.0.tgz" + integrity sha512-amJnQCcgtRVw9SvoebO3BKGESClrfXGCUTX9hSn1OuGQTQBOZmVd0Z0OlecpuRksKvbsUqALE8jls/ErClAPuQ== + +nofilter@^1.0.4: + version "1.0.4" + resolved "https://registry.yarnpkg.com/nofilter/-/nofilter-1.0.4.tgz#78d6f4b6a613e7ced8b015cec534625f7667006e" + integrity sha512-N8lidFp+fCz+TD51+haYdbDGrcBWwuHX40F5+z0qkUjMJ5Tp+rdSuAkMJ9N9eoolDlEVTf6u5icM+cNKkKW2mA== + +nofilter@^3.1.0: + version "3.1.0" + resolved "https://registry.yarnpkg.com/nofilter/-/nofilter-3.1.0.tgz#c757ba68801d41ff930ba2ec55bab52ca184aa66" + integrity sha512-l2NNj07e9afPnhAhvgVrCD/oy2Ai1yfLpuo3EpiO1jFTsB4sFz6oIfAfSZyQzVpkZQ9xS8ZS5g1jCBgq4Hwo0g== + +nopt@3.x: + version "3.0.6" + resolved "https://registry.npmjs.org/nopt/-/nopt-3.0.6.tgz" + integrity sha1-xkZdvwirzU2zWTF/eaxopkayj/k= + dependencies: + abbrev "1" + +normalize-package-data@^2.3.2: + version "2.5.0" + resolved "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.5.0.tgz" + integrity sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA== + dependencies: + hosted-git-info "^2.1.4" + resolve "^1.10.0" + semver "2 || 3 || 4 || 5" + validate-npm-package-license "^3.0.1" + +normalize-path@^3.0.0, normalize-path@~3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz" + integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA== + +normalize-url@^4.1.0: + version "4.5.1" + resolved "https://registry.npmjs.org/normalize-url/-/normalize-url-4.5.1.tgz" + integrity sha512-9UZCFRHQdNrfTpGg8+1INIg93B6zE0aXMVFkw1WFwvO4SlZywU6aLg5Of0Ap/PgcbSw4LNxvMWXMeugwMCX0AA== + +npm-run-path@^4.0.1: + version "4.0.1" + resolved "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz" + integrity sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw== + dependencies: + path-key "^3.0.0" + +number-is-nan@^1.0.0: + version "1.0.1" + resolved "https://registry.npmjs.org/number-is-nan/-/number-is-nan-1.0.1.tgz" + integrity sha1-CXtgK1NCKlIsGvuHkDGDNpQaAR0= + +number-to-bn@1.7.0: + version "1.7.0" + resolved "https://registry.npmjs.org/number-to-bn/-/number-to-bn-1.7.0.tgz" + integrity sha1-uzYjWS9+X54AMLGXe9QaDFP+HqA= + dependencies: + bn.js "4.11.6" + strip-hex-prefix "1.0.0" + +oauth-sign@~0.9.0: + version "0.9.0" + resolved "https://registry.npmjs.org/oauth-sign/-/oauth-sign-0.9.0.tgz" + integrity sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ== + +object-assign@^4, object-assign@^4.0.0, object-assign@^4.1.0, object-assign@^4.1.1: + version "4.1.1" + resolved "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz" + integrity sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM= + +object-copy@^0.1.0: + version "0.1.0" + resolved "https://registry.npmjs.org/object-copy/-/object-copy-0.1.0.tgz" + integrity sha1-fn2Fi3gb18mRpBupde04EnVOmYw= + dependencies: + copy-descriptor "^0.1.0" + define-property "^0.2.5" + kind-of "^3.0.3" + +object-inspect@^1.12.0, object-inspect@^1.9.0, object-inspect@~1.12.0: + version "1.12.0" + resolved "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.0.tgz" + integrity sha512-Ho2z80bVIvJloH+YzRmpZVQe87+qASmBUKZDWgx9cu+KDrX2ZDH/3tMy+gXbZETVGs2M8YdxObOh7XAtim9Y0g== + +object-is@^1.0.1: + version "1.1.5" + resolved "https://registry.yarnpkg.com/object-is/-/object-is-1.1.5.tgz#b9deeaa5fc7f1846a0faecdceec138e5778f53ac" + integrity sha512-3cyDsyHgtmi7I7DfSSI2LDp6SK2lwvtbg0p0R1e0RvTqF5ceGx+K2dfSjm1bKDMVCFEDAQvy+o8c6a7VujOddw== + dependencies: + call-bind "^1.0.2" + define-properties "^1.1.3" + +object-keys@^1.0.11, object-keys@^1.1.1: + version "1.1.1" + resolved "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz" + integrity sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA== + +object-keys@~0.4.0: + version "0.4.0" + resolved "https://registry.npmjs.org/object-keys/-/object-keys-0.4.0.tgz" + integrity sha1-KKaq50KN0sOpLz2V8hM13SBOAzY= + +object-visit@^1.0.0: + version "1.0.1" + resolved "https://registry.npmjs.org/object-visit/-/object-visit-1.0.1.tgz" + integrity sha1-95xEk68MU3e1n+OdOV5BBC3QRbs= + dependencies: + isobject "^3.0.0" + +object.assign@4.1.0: + version "4.1.0" + resolved "https://registry.npmjs.org/object.assign/-/object.assign-4.1.0.tgz" + integrity sha512-exHJeq6kBKj58mqGyTQ9DFvrZC/eR6OwxzoM9YRoGBqrXYonaFyGiFMuc9VZrXf7DarreEwMpurG3dd+CNyW5w== + dependencies: + define-properties "^1.1.2" + function-bind "^1.1.1" + has-symbols "^1.0.0" + object-keys "^1.0.11" + +object.assign@^4.1.2: + version "4.1.2" + resolved "https://registry.npmjs.org/object.assign/-/object.assign-4.1.2.tgz" + integrity sha512-ixT2L5THXsApyiUPYKmW+2EHpXXe5Ii3M+f4e+aJFAHao5amFRW6J0OO6c/LU8Be47utCx2GL89hxGB6XSmKuQ== + dependencies: + call-bind "^1.0.0" + define-properties "^1.1.3" + has-symbols "^1.0.1" + object-keys "^1.1.1" + +object.getownpropertydescriptors@^2.0.3, object.getownpropertydescriptors@^2.1.1: + version "2.1.3" + resolved "https://registry.yarnpkg.com/object.getownpropertydescriptors/-/object.getownpropertydescriptors-2.1.3.tgz#b223cf38e17fefb97a63c10c91df72ccb386df9e" + integrity sha512-VdDoCwvJI4QdC6ndjpqFmoL3/+HxffFBbcJzKi5hwLLqqx3mdbedRpfZDdK0SrOSauj8X4GzBvnDZl4vTN7dOw== + dependencies: + call-bind "^1.0.2" + define-properties "^1.1.3" + es-abstract "^1.19.1" + +object.pick@^1.3.0: + version "1.3.0" + resolved "https://registry.npmjs.org/object.pick/-/object.pick-1.3.0.tgz" + integrity sha1-h6EKxMFpS9Lhy/U1kaZhQftd10c= + dependencies: + isobject "^3.0.1" + +object.values@^1.1.5: + version "1.1.5" + resolved "https://registry.npmjs.org/object.values/-/object.values-1.1.5.tgz" + integrity sha512-QUZRW0ilQ3PnPpbNtgdNV1PDbEqLIiSFB3l+EnGtBQ/8SUTLj1PZwtQHABZtLgwpJZTSZhuGLOGk57Drx2IvYg== + dependencies: + call-bind "^1.0.2" + define-properties "^1.1.3" + es-abstract "^1.19.1" + +obliterator@^2.0.0: + version "2.0.3" + resolved "https://registry.npmjs.org/obliterator/-/obliterator-2.0.3.tgz" + integrity sha512-qN5lHhArxl/789Bp3XCpssAYy7cvOdRzxzflmGEJaiipAT2b/USr1XvKjYyssPOwQ/3KjV1e8Ed9po9rie6E6A== + +oboe@2.1.4: + version "2.1.4" + resolved "https://registry.npmjs.org/oboe/-/oboe-2.1.4.tgz" + integrity sha1-IMiM2wwVNxuwQRklfU/dNLCqSfY= + dependencies: + http-https "^1.0.0" + +oboe@2.1.5: + version "2.1.5" + resolved "https://registry.npmjs.org/oboe/-/oboe-2.1.5.tgz" + integrity sha1-VVQoTFQ6ImbXo48X4HOCH73jk80= + dependencies: + http-https "^1.0.0" + +on-finished@2.4.1: + version "2.4.1" + resolved "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz" + integrity sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg== + dependencies: + ee-first "1.1.1" + +once@1.x, once@^1.3.0, once@^1.3.1, once@^1.4.0: + version "1.4.0" + resolved "https://registry.npmjs.org/once/-/once-1.4.0.tgz" + integrity sha1-WDsap3WWHUsROsF9nFC6753Xa9E= + dependencies: + wrappy "1" + +onetime@^2.0.0: + version "2.0.1" + resolved "https://registry.npmjs.org/onetime/-/onetime-2.0.1.tgz" + integrity sha1-BnQoIw/WdEOyeUsiu6UotoZ5YtQ= + dependencies: + mimic-fn "^1.0.0" + +onetime@^5.1.0, onetime@^5.1.2: + version "5.1.2" + resolved "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz" + integrity sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg== + dependencies: + mimic-fn "^2.1.0" + +open@^7.4.2: + version "7.4.2" + resolved "https://registry.npmjs.org/open/-/open-7.4.2.tgz" + integrity sha512-MVHddDVweXZF3awtlAS+6pgKLlm/JgxZ90+/NBurBoQctVOOB/zDdVjcyPzQ+0laDGbsWgrRkflI65sQeOgT9Q== + dependencies: + is-docker "^2.0.0" + is-wsl "^2.1.1" + +optionator@^0.8.1, optionator@^0.8.2: + version "0.8.3" + resolved "https://registry.npmjs.org/optionator/-/optionator-0.8.3.tgz" + integrity sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA== + dependencies: + deep-is "~0.1.3" + fast-levenshtein "~2.0.6" + levn "~0.3.0" + prelude-ls "~1.1.2" + type-check "~0.3.2" + word-wrap "~1.2.3" + +optionator@^0.9.1: + version "0.9.1" + resolved "https://registry.npmjs.org/optionator/-/optionator-0.9.1.tgz" + integrity sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw== + dependencies: + deep-is "^0.1.3" + fast-levenshtein "^2.0.6" + levn "^0.4.1" + prelude-ls "^1.2.1" + type-check "^0.4.0" + word-wrap "^1.2.3" + +os-homedir@^1.0.0: + version "1.0.2" + resolved "https://registry.npmjs.org/os-homedir/-/os-homedir-1.0.2.tgz" + integrity sha1-/7xJiDNuDoM94MFox+8VISGqf7M= + +os-locale@^1.4.0: + version "1.4.0" + resolved "https://registry.npmjs.org/os-locale/-/os-locale-1.4.0.tgz" + integrity sha1-IPnxeuKe00XoveWDsT0gCYA8FNk= + dependencies: + lcid "^1.0.0" + +os-tmpdir@^1.0.1, os-tmpdir@~1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz" + integrity sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ= + +p-cancelable@^0.3.0: + version "0.3.0" + resolved "https://registry.npmjs.org/p-cancelable/-/p-cancelable-0.3.0.tgz" + integrity sha512-RVbZPLso8+jFeq1MfNvgXtCRED2raz/dKpacfTNxsx6pLEpEomM7gah6VeHSYV3+vo0OAi4MkArtQcWWXuQoyw== + +p-cancelable@^1.0.0: + version "1.1.0" + resolved "https://registry.npmjs.org/p-cancelable/-/p-cancelable-1.1.0.tgz" + integrity sha512-s73XxOZ4zpt1edZYZzvhqFa6uvQc1vwUa0K0BdtIZgQMAJj9IbebH+JkgKZc9h+B05PKHLOTl4ajG1BmNrVZlw== + +p-finally@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/p-finally/-/p-finally-1.0.0.tgz" + integrity sha1-P7z7FbiZpEEjs0ttzBi3JDNqLK4= + +p-limit@^1.1.0: + version "1.3.0" + resolved "https://registry.npmjs.org/p-limit/-/p-limit-1.3.0.tgz" + integrity sha512-vvcXsLAJ9Dr5rQOPk7toZQZJApBl2K4J6dANSsEuh6QI41JYcsS/qhTGa9ErIUUgK3WNQoJYvylxvjqmiqEA9Q== + dependencies: + p-try "^1.0.0" + +p-limit@^2.0.0: + version "2.3.0" + resolved "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz" + integrity sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w== + dependencies: + p-try "^2.0.0" + +p-limit@^3.0.2: + version "3.1.0" + resolved "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz" + integrity sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ== + dependencies: + yocto-queue "^0.1.0" + +p-locate@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/p-locate/-/p-locate-2.0.0.tgz" + integrity sha1-IKAQOyIqcMj9OcwuWAaA893l7EM= + dependencies: + p-limit "^1.1.0" + +p-locate@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/p-locate/-/p-locate-3.0.0.tgz" + integrity sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ== + dependencies: + p-limit "^2.0.0" + +p-locate@^5.0.0: + version "5.0.0" + resolved "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz" + integrity sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw== + dependencies: + p-limit "^3.0.2" + +p-map@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/p-map/-/p-map-4.0.0.tgz" + integrity sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ== + dependencies: + aggregate-error "^3.0.0" + +p-timeout@^1.1.1: + version "1.2.1" + resolved "https://registry.npmjs.org/p-timeout/-/p-timeout-1.2.1.tgz" + integrity sha1-XrOzU7f86Z8QGhA4iAuwVOu+o4Y= + dependencies: + p-finally "^1.0.0" + +p-try@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/p-try/-/p-try-1.0.0.tgz" + integrity sha1-y8ec26+P1CKOE/Yh8rGiN8GyB7M= + +p-try@^2.0.0: + version "2.2.0" + resolved "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz" + integrity sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ== + +parent-module@^1.0.0: + version "1.0.1" + resolved "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz" + integrity sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g== + dependencies: + callsites "^3.0.0" + +parse-asn1@^5.0.0, parse-asn1@^5.1.5: + version "5.1.6" + resolved "https://registry.npmjs.org/parse-asn1/-/parse-asn1-5.1.6.tgz" + integrity sha512-RnZRo1EPU6JBnra2vGHj0yhp6ebyjBZpmUCLHWiFhxlzvBCCpAuZ7elsBp1PVAbQN0/04VD/19rfzlBSwLstMw== + dependencies: + asn1.js "^5.2.0" + browserify-aes "^1.0.0" + evp_bytestokey "^1.0.0" + pbkdf2 "^3.0.3" + safe-buffer "^5.1.1" + +parse-cache-control@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/parse-cache-control/-/parse-cache-control-1.0.1.tgz" + integrity sha1-juqz5U+laSD+Fro493+iGqzC104= + +parse-headers@^2.0.0: + version "2.0.5" + resolved "https://registry.npmjs.org/parse-headers/-/parse-headers-2.0.5.tgz" + integrity sha512-ft3iAoLOB/MlwbNXgzy43SWGP6sQki2jQvAyBg/zDFAgr9bfNWZIUj42Kw2eJIl8kEi4PbgE6U1Zau/HwI75HA== + +parse-json@^2.2.0: + version "2.2.0" + resolved "https://registry.npmjs.org/parse-json/-/parse-json-2.2.0.tgz" + integrity sha1-9ID0BDTvgHQfhGkJn43qGPVaTck= + dependencies: + error-ex "^1.2.0" + +parse-json@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/parse-json/-/parse-json-4.0.0.tgz" + integrity sha1-vjX1Qlvh9/bHRxhPmKeIy5lHfuA= + dependencies: + error-ex "^1.3.1" + json-parse-better-errors "^1.0.1" + +parseurl@~1.3.3: + version "1.3.3" + resolved "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz" + integrity sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ== + +pascalcase@^0.1.1: + version "0.1.1" + resolved "https://registry.npmjs.org/pascalcase/-/pascalcase-0.1.1.tgz" + integrity sha1-s2PlXoAGym/iF4TS2yK9FdeRfxQ= + +patch-package@6.2.2: + version "6.2.2" + resolved "https://registry.npmjs.org/patch-package/-/patch-package-6.2.2.tgz" + integrity sha512-YqScVYkVcClUY0v8fF0kWOjDYopzIM8e3bj/RU1DPeEF14+dCGm6UeOYm4jvCyxqIEQ5/eJzmbWfDWnUleFNMg== + dependencies: + "@yarnpkg/lockfile" "^1.1.0" + chalk "^2.4.2" + cross-spawn "^6.0.5" + find-yarn-workspace-root "^1.2.1" + fs-extra "^7.0.1" + is-ci "^2.0.0" + klaw-sync "^6.0.0" + minimist "^1.2.0" + rimraf "^2.6.3" + semver "^5.6.0" + slash "^2.0.0" + tmp "^0.0.33" + +patch-package@^6.2.2: + version "6.4.7" + resolved "https://registry.npmjs.org/patch-package/-/patch-package-6.4.7.tgz" + integrity sha512-S0vh/ZEafZ17hbhgqdnpunKDfzHQibQizx9g8yEf5dcVk3KOflOfdufRXQX8CSEkyOQwuM/bNz1GwKvFj54kaQ== + dependencies: + "@yarnpkg/lockfile" "^1.1.0" + chalk "^2.4.2" + cross-spawn "^6.0.5" + find-yarn-workspace-root "^2.0.0" + fs-extra "^7.0.1" + is-ci "^2.0.0" + klaw-sync "^6.0.0" + minimist "^1.2.0" + open "^7.4.2" + rimraf "^2.6.3" + semver "^5.6.0" + slash "^2.0.0" + tmp "^0.0.33" + +path-browserify@^1.0.0: + version "1.0.1" + resolved "https://registry.npmjs.org/path-browserify/-/path-browserify-1.0.1.tgz" + integrity sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g== + +path-exists@^2.0.0: + version "2.1.0" + resolved "https://registry.npmjs.org/path-exists/-/path-exists-2.1.0.tgz" + integrity sha1-D+tsZPD8UY2adU3V77YscCJ2H0s= + dependencies: + pinkie-promise "^2.0.0" + +path-exists@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz" + integrity sha1-zg6+ql94yxiSXqfYENe1mwEP1RU= + +path-exists@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz" + integrity sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w== + +path-is-absolute@^1.0.0, path-is-absolute@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz" + integrity sha1-F0uSaHNVNP+8es5r9TpanhtcX18= + +path-is-inside@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/path-is-inside/-/path-is-inside-1.0.2.tgz" + integrity sha1-NlQX3t5EQw0cEa9hAn+s8HS9/FM= + +path-key@^2.0.1: + version "2.0.1" + resolved "https://registry.npmjs.org/path-key/-/path-key-2.0.1.tgz" + integrity sha1-QRyttXTFoUDTpLGRDUDYDMn0C0A= + +path-key@^3.0.0, path-key@^3.1.0: + version "3.1.1" + resolved "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz" + integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q== + +path-parse@^1.0.6, path-parse@^1.0.7: + version "1.0.7" + resolved "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz" + integrity sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw== + +path-to-regexp@0.1.7: + version "0.1.7" + resolved "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.7.tgz" + integrity sha1-32BBeABfUi8V60SQ5yR6G/qmf4w= + +path-type@^1.0.0: + version "1.1.0" + resolved "https://registry.npmjs.org/path-type/-/path-type-1.1.0.tgz" + integrity sha1-WcRPfuSR2nBNpBXaWkBwuk+P5EE= + dependencies: + graceful-fs "^4.1.2" + pify "^2.0.0" + pinkie-promise "^2.0.0" + +path-type@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz" + integrity sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw== + +pathval@^1.1.1: + version "1.1.1" + resolved "https://registry.npmjs.org/pathval/-/pathval-1.1.1.tgz" + integrity sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ== + +pbkdf2@^3.0.17, pbkdf2@^3.0.3, pbkdf2@^3.0.9: + version "3.1.2" + resolved "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.1.2.tgz" + integrity sha512-iuh7L6jA7JEGu2WxDwtQP1ddOpaJNC4KlDEFfdQajSGgGPNi4OyDc2R7QnbY2bR9QjBVGwgvTdNJZoE7RaxUMA== + dependencies: + create-hash "^1.1.2" + create-hmac "^1.1.4" + ripemd160 "^2.0.1" + safe-buffer "^5.0.1" + sha.js "^2.4.8" + +performance-now@^2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz" + integrity sha1-Ywn04OX6kT7BxpMHrjZLSzd8nns= + +picomatch@^2.0.4, picomatch@^2.2.1, picomatch@^2.3.1: + version "2.3.1" + resolved "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz" + integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA== + +pidtree@^0.5.0: + version "0.5.0" + resolved "https://registry.npmjs.org/pidtree/-/pidtree-0.5.0.tgz" + integrity sha512-9nxspIM7OpZuhBxPg73Zvyq7j1QMPMPsGKTqRc2XOaFQauDvoNz9fM1Wdkjmeo7l9GXOZiRs97sPkuayl39wjA== + +pify@^2.0.0, pify@^2.3.0: + version "2.3.0" + resolved "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz" + integrity sha1-7RQaasBDqEnqWISY59yosVMw6Qw= + +pify@^4.0.1: + version "4.0.1" + resolved "https://registry.npmjs.org/pify/-/pify-4.0.1.tgz" + integrity sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g== + +pinkie-promise@^2.0.0: + version "2.0.1" + resolved "https://registry.npmjs.org/pinkie-promise/-/pinkie-promise-2.0.1.tgz" + integrity sha1-ITXW36ejWMBprJsXh3YogihFD/o= + dependencies: + pinkie "^2.0.0" + +pinkie@^2.0.0: + version "2.0.4" + resolved "https://registry.npmjs.org/pinkie/-/pinkie-2.0.4.tgz" + integrity sha1-clVrgM+g1IqXToDnckjoDtT3+HA= + +posix-character-classes@^0.1.0: + version "0.1.1" + resolved "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz" + integrity sha1-AerA/jta9xoqbAL+q7jB/vfgDqs= + +postinstall-postinstall@^2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/postinstall-postinstall/-/postinstall-postinstall-2.1.0.tgz" + integrity sha512-7hQX6ZlZXIoRiWNrbMQaLzUUfH+sSx39u8EJ9HYuDc1kLo9IXKWjM5RSquZN1ad5GnH8CGFM78fsAAQi3OKEEQ== + +precond@0.2: + version "0.2.3" + resolved "https://registry.npmjs.org/precond/-/precond-0.2.3.tgz" + integrity sha1-qpWRvKokkj8eD0hJ0kD0fvwQdaw= + +prelude-ls@^1.2.1: + version "1.2.1" + resolved "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz" + integrity sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g== + +prelude-ls@~1.1.2: + version "1.1.2" + resolved "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz" + integrity sha1-IZMqVJ9eUv/ZqCf1cOBL5iqX2lQ= + +prepend-http@^1.0.1: + version "1.0.4" + resolved "https://registry.npmjs.org/prepend-http/-/prepend-http-1.0.4.tgz" + integrity sha1-1PRWKwzjaW5BrFLQ4ALlemNdxtw= + +prepend-http@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/prepend-http/-/prepend-http-2.0.0.tgz" + integrity sha1-6SQ0v6XqjBn0HN/UAddBo8gZ2Jc= + +prettier-linter-helpers@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/prettier-linter-helpers/-/prettier-linter-helpers-1.0.0.tgz" + integrity sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w== + dependencies: + fast-diff "^1.1.2" + +prettier-plugin-solidity@^1.0.0-beta.19: + version "1.0.0-beta.19" + resolved "https://registry.npmjs.org/prettier-plugin-solidity/-/prettier-plugin-solidity-1.0.0-beta.19.tgz" + integrity sha512-xxRQ5ZiiZyUoMFLE9h7HnUDXI/daf1tnmL1msEdcKmyh7ZGQ4YklkYLC71bfBpYU2WruTb5/SFLUaEb3RApg5g== + dependencies: + "@solidity-parser/parser" "^0.14.0" + emoji-regex "^10.0.0" + escape-string-regexp "^4.0.0" + semver "^7.3.5" + solidity-comments-extractor "^0.0.7" + string-width "^4.2.3" + +prettier@^1.14.3: + version "1.19.1" + resolved "https://registry.npmjs.org/prettier/-/prettier-1.19.1.tgz" + integrity sha512-s7PoyDv/II1ObgQunCbB9PdLmUcBZcnWOcxDh7O0N/UwDEsHyqkW+Qh28jW+mVuCdx7gLB0BotYI1Y6uI9iyew== + +prettier@^2.1.2, prettier@^2.3.1, prettier@^2.5.1: + version "2.6.2" + resolved "https://registry.npmjs.org/prettier/-/prettier-2.6.2.tgz" + integrity sha512-PkUpF+qoXTqhOeWL9fu7As8LXsIUZ1WYaJiY/a7McAQzxjk82OF0tibkFXVCDImZtWxbvojFjerkiLb0/q8mew== + +private@^0.1.6, private@^0.1.8: + version "0.1.8" + resolved "https://registry.npmjs.org/private/-/private-0.1.8.tgz" + integrity sha512-VvivMrbvd2nKkiG38qjULzlc+4Vx4wm/whI9pQD35YrARNnhxeiRktSOhSukRLFNlzg6Br/cJPet5J/u19r/mg== + +process-nextick-args@~2.0.0: + version "2.0.1" + resolved "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz" + integrity sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag== + +process@^0.11.10: + version "0.11.10" + resolved "https://registry.npmjs.org/process/-/process-0.11.10.tgz" + integrity sha1-czIwDoQBYb2j5podHZGn1LwW8YI= + +progress@^2.0.0: + version "2.0.3" + resolved "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz" + integrity sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA== + +promise-to-callback@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/promise-to-callback/-/promise-to-callback-1.0.0.tgz" + integrity sha1-XSp0kBC/tn2WNZj805YHRqaP7vc= + dependencies: + is-fn "^1.0.0" + set-immediate-shim "^1.0.1" + +promise@^8.0.0: + version "8.1.0" + resolved "https://registry.npmjs.org/promise/-/promise-8.1.0.tgz" + integrity sha512-W04AqnILOL/sPRXziNicCjSNRruLAuIHEOVBazepu0545DDNGYHz7ar9ZgZ1fMU8/MA4mVxp5rkBWRi6OXIy3Q== + dependencies: + asap "~2.0.6" + +proper-lockfile@^4.1.1: + version "4.1.2" + resolved "https://registry.yarnpkg.com/proper-lockfile/-/proper-lockfile-4.1.2.tgz#c8b9de2af6b2f1601067f98e01ac66baa223141f" + integrity sha512-TjNPblN4BwAWMXU8s9AEz4JmQxnD1NNL7bNOY/AKUzyamc379FWASUhc/K1pL2noVb+XmZKLL68cjzLsiOAMaA== + dependencies: + graceful-fs "^4.2.4" + retry "^0.12.0" + signal-exit "^3.0.2" + +proxy-addr@~2.0.7: + version "2.0.7" + resolved "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz" + integrity sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg== + dependencies: + forwarded "0.2.0" + ipaddr.js "1.9.1" + +prr@~1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/prr/-/prr-1.0.1.tgz" + integrity sha1-0/wRS6BplaRexok/SEzrHXj19HY= + +pseudomap@^1.0.1: + version "1.0.2" + resolved "https://registry.npmjs.org/pseudomap/-/pseudomap-1.0.2.tgz" + integrity sha1-8FKijacOYYkX7wqKw0wa5aaChrM= + +psl@^1.1.28: + version "1.8.0" + resolved "https://registry.npmjs.org/psl/-/psl-1.8.0.tgz" + integrity sha512-RIdOzyoavK+hA18OGGWDqUTsCLhtA7IcZ/6NCs4fFJaHBDab+pDDmDIByWFRQJq2Cd7r1OoQxBGKOaztq+hjIQ== + +public-encrypt@^4.0.0: + version "4.0.3" + resolved "https://registry.npmjs.org/public-encrypt/-/public-encrypt-4.0.3.tgz" + integrity sha512-zVpa8oKZSz5bTMTFClc1fQOnyyEzpl5ozpi1B5YcvBrdohMjH2rfsBtyXcuNuwjsDIXmBYlF2N5FlJYhR29t8Q== + dependencies: + bn.js "^4.1.0" + browserify-rsa "^4.0.0" + create-hash "^1.1.0" + parse-asn1 "^5.0.0" + randombytes "^2.0.1" + safe-buffer "^5.1.2" + +pull-cat@^1.1.9: + version "1.1.11" + resolved "https://registry.npmjs.org/pull-cat/-/pull-cat-1.1.11.tgz" + integrity sha1-tkLdElXaN2pwa220+pYvX9t0wxs= + +pull-defer@^0.2.2: + version "0.2.3" + resolved "https://registry.npmjs.org/pull-defer/-/pull-defer-0.2.3.tgz" + integrity sha512-/An3KE7mVjZCqNhZsr22k1Tx8MACnUnHZZNPSJ0S62td8JtYr/AiRG42Vz7Syu31SoTLUzVIe61jtT/pNdjVYA== + +pull-level@^2.0.3: + version "2.0.4" + resolved "https://registry.npmjs.org/pull-level/-/pull-level-2.0.4.tgz" + integrity sha512-fW6pljDeUThpq5KXwKbRG3X7Ogk3vc75d5OQU/TvXXui65ykm+Bn+fiktg+MOx2jJ85cd+sheufPL+rw9QSVZg== + dependencies: + level-post "^1.0.7" + pull-cat "^1.1.9" + pull-live "^1.0.1" + pull-pushable "^2.0.0" + pull-stream "^3.4.0" + pull-window "^2.1.4" + stream-to-pull-stream "^1.7.1" + +pull-live@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/pull-live/-/pull-live-1.0.1.tgz" + integrity sha1-pOzuAeMwFV6RJLu89HYfIbOPUfU= + dependencies: + pull-cat "^1.1.9" + pull-stream "^3.4.0" + +pull-pushable@^2.0.0: + version "2.2.0" + resolved "https://registry.npmjs.org/pull-pushable/-/pull-pushable-2.2.0.tgz" + integrity sha1-Xy867UethpGfAbEqLpnW8b13ZYE= + +pull-stream@^3.2.3, pull-stream@^3.4.0, pull-stream@^3.6.8: + version "3.6.14" + resolved "https://registry.npmjs.org/pull-stream/-/pull-stream-3.6.14.tgz" + integrity sha512-KIqdvpqHHaTUA2mCYcLG1ibEbu/LCKoJZsBWyv9lSYtPkJPBq8m3Hxa103xHi6D2thj5YXa0TqK3L3GUkwgnew== + +pull-window@^2.1.4: + version "2.1.4" + resolved "https://registry.npmjs.org/pull-window/-/pull-window-2.1.4.tgz" + integrity sha1-/DuG/uvRkgx64pdpHiP3BfiFUvA= + dependencies: + looper "^2.0.0" + +pump@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/pump/-/pump-3.0.0.tgz" + integrity sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww== + dependencies: + end-of-stream "^1.1.0" + once "^1.3.1" + +punycode@1.3.2: + version "1.3.2" + resolved "https://registry.npmjs.org/punycode/-/punycode-1.3.2.tgz" + integrity sha1-llOgNvt8HuQjQvIyXM7v6jkmxI0= + +punycode@2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/punycode/-/punycode-2.1.0.tgz" + integrity sha1-X4Y+3Im5bbCQdLrXlHvwkFbKTn0= + +punycode@^2.1.0, punycode@^2.1.1: + version "2.1.1" + resolved "https://registry.npmjs.org/punycode/-/punycode-2.1.1.tgz" + integrity sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A== + +qs@6.10.3, qs@^6.4.0, qs@^6.7.0: + version "6.10.3" + resolved "https://registry.npmjs.org/qs/-/qs-6.10.3.tgz" + integrity sha512-wr7M2E0OFRfIfJZjKGieI8lBKb7fRCH4Fv5KNPEs7gJ8jadvotdsS08PzOKR7opXhZ/Xkjtt3WF9g38drmyRqQ== + dependencies: + side-channel "^1.0.4" + +qs@^6.9.4: + version "6.10.5" + resolved "https://registry.yarnpkg.com/qs/-/qs-6.10.5.tgz#974715920a80ff6a262264acd2c7e6c2a53282b4" + integrity sha512-O5RlPh0VFtR78y79rgcgKK4wbAI0C5zGVLztOIdpWX6ep368q5Hv6XRxDvXuZ9q3C6v+e3n8UfZZJw7IIG27eQ== + dependencies: + side-channel "^1.0.4" + +qs@~6.5.2: + version "6.5.3" + resolved "https://registry.yarnpkg.com/qs/-/qs-6.5.3.tgz#3aeeffc91967ef6e35c0e488ef46fb296ab76aad" + integrity sha512-qxXIEh4pCGfHICj1mAJQ2/2XVZkjCDTcEgfoSQxc/fYivUZxTkk7L3bDBJSoNrEzXI17oUO5Dp07ktqE5KzczA== + +query-string@^5.0.1: + version "5.1.1" + resolved "https://registry.npmjs.org/query-string/-/query-string-5.1.1.tgz" + integrity sha512-gjWOsm2SoGlgLEdAGt7a6slVOk9mGiXmPFMqrEhLQ68rhQuBnpfs3+EmlvqKyxnCo9/PPlF+9MtY02S1aFg+Jw== + dependencies: + decode-uri-component "^0.2.0" + object-assign "^4.1.0" + strict-uri-encode "^1.0.0" + +querystring@0.2.0: + version "0.2.0" + resolved "https://registry.npmjs.org/querystring/-/querystring-0.2.0.tgz" + integrity sha1-sgmEkgO7Jd+CDadW50cAWHhSFiA= + +queue-microtask@^1.2.2: + version "1.2.3" + resolved "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz" + integrity sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A== + +randombytes@^2.0.0, randombytes@^2.0.1, randombytes@^2.0.5, randombytes@^2.0.6, randombytes@^2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz" + integrity sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ== + dependencies: + safe-buffer "^5.1.0" + +randomfill@^1.0.3: + version "1.0.4" + resolved "https://registry.npmjs.org/randomfill/-/randomfill-1.0.4.tgz" + integrity sha512-87lcbR8+MhcWcUiQ+9e+Rwx8MyR2P7qnt15ynUlbm3TU/fjbgz4GsvfSUDTemtCCtVCqb4ZcEFlyPNTh9bBTLw== + dependencies: + randombytes "^2.0.5" + safe-buffer "^5.1.0" + +range-parser@~1.2.1: + version "1.2.1" + resolved "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz" + integrity sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg== + +raw-body@2.5.1, raw-body@^2.4.1: + version "2.5.1" + resolved "https://registry.npmjs.org/raw-body/-/raw-body-2.5.1.tgz" + integrity sha512-qqJBtEyVgS0ZmPGdCFPWJ3FreoqvG4MVQln/kCgF7Olq95IbOp0/BWyMwbdtn4VTvkM8Y7khCQ2Xgk/tcrCXig== + dependencies: + bytes "3.1.2" + http-errors "2.0.0" + iconv-lite "0.4.24" + unpipe "1.0.0" + +read-pkg-up@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-1.0.1.tgz" + integrity sha1-nWPBMnbAZZGNV/ACpX9AobZD+wI= + dependencies: + find-up "^1.0.0" + read-pkg "^1.0.0" + +read-pkg@^1.0.0: + version "1.1.0" + resolved "https://registry.npmjs.org/read-pkg/-/read-pkg-1.1.0.tgz" + integrity sha1-9f+qXs0pyzHAR0vKfXVra7KePyg= + dependencies: + load-json-file "^1.0.0" + normalize-package-data "^2.3.2" + path-type "^1.0.0" + +readable-stream@^1.0.33: + version "1.1.14" + resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz" + integrity sha1-fPTFTvZI44EwhMY23SB54WbAgdk= + dependencies: + core-util-is "~1.0.0" + inherits "~2.0.1" + isarray "0.0.1" + string_decoder "~0.10.x" + +readable-stream@^2.0.0, readable-stream@^2.0.5, readable-stream@^2.2.2, readable-stream@^2.2.8, readable-stream@^2.2.9, readable-stream@^2.3.6, readable-stream@~2.3.6: + version "2.3.7" + resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.7.tgz" + integrity sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw== + dependencies: + core-util-is "~1.0.0" + inherits "~2.0.3" + isarray "~1.0.0" + process-nextick-args "~2.0.0" + safe-buffer "~5.1.1" + string_decoder "~1.1.1" + util-deprecate "~1.0.1" + +readable-stream@^3.0.6, readable-stream@^3.1.0, readable-stream@^3.4.0, readable-stream@^3.6.0: + version "3.6.0" + resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz" + integrity sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA== + dependencies: + inherits "^2.0.3" + string_decoder "^1.1.1" + util-deprecate "^1.0.1" + +readable-stream@~1.0.15: + version "1.0.34" + resolved "https://registry.npmjs.org/readable-stream/-/readable-stream-1.0.34.tgz" + integrity sha1-Elgg40vIQtLyqq+v5MKRbuMsFXw= + dependencies: + core-util-is "~1.0.0" + inherits "~2.0.1" + isarray "0.0.1" + string_decoder "~0.10.x" + +readdirp@~3.2.0: + version "3.2.0" + resolved "https://registry.npmjs.org/readdirp/-/readdirp-3.2.0.tgz" + integrity sha512-crk4Qu3pmXwgxdSgGhgA/eXiJAPQiX4GMOZZMXnqKxHX7TaoL+3gQVo/WeuAiogr07DpnfjIMpXXa+PAIvwPGQ== + dependencies: + picomatch "^2.0.4" + +readdirp@~3.6.0: + version "3.6.0" + resolved "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz" + integrity sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA== + dependencies: + picomatch "^2.2.1" + +readline-sync@^1.4.10: + version "1.4.10" + resolved "https://registry.yarnpkg.com/readline-sync/-/readline-sync-1.4.10.tgz#41df7fbb4b6312d673011594145705bf56d8873b" + integrity sha512-gNva8/6UAe8QYepIQH/jQ2qn91Qj0B9sYjMBBs3QOB8F2CXcKgLxQaJRP76sWVRQt+QU+8fAkCbCvjjMFu7Ycw== + +rechoir@^0.6.2: + version "0.6.2" + resolved "https://registry.npmjs.org/rechoir/-/rechoir-0.6.2.tgz" + integrity sha1-hSBLVNuoLVdC4oyWdW70OvUOM4Q= + dependencies: + resolve "^1.1.6" + +recursive-readdir@^2.2.2: + version "2.2.2" + resolved "https://registry.npmjs.org/recursive-readdir/-/recursive-readdir-2.2.2.tgz" + integrity sha512-nRCcW9Sj7NuZwa2XvH9co8NPeXUBhZP7CRKJtU+cS6PW9FpCIFoI5ib0NT1ZrbNuPoRy0ylyCaUL8Gih4LSyFg== + dependencies: + minimatch "3.0.4" + +reduce-flatten@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/reduce-flatten/-/reduce-flatten-2.0.0.tgz" + integrity sha512-EJ4UNY/U1t2P/2k6oqotuX2Cc3T6nxJwsM0N0asT7dhrtH1ltUxDn4NalSYmPE2rCkVpcf/X6R0wDwcFpzhd4w== + +regenerate@^1.2.1: + version "1.4.2" + resolved "https://registry.npmjs.org/regenerate/-/regenerate-1.4.2.tgz" + integrity sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A== + +regenerator-runtime@^0.11.0: + version "0.11.1" + resolved "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.11.1.tgz" + integrity sha512-MguG95oij0fC3QV3URf4V2SDYGJhJnJGqvIIgdECeODCT98wSWDAJ94SSuVpYQUoTcGUIL6L4yNB7j1DFFHSBg== + +regenerator-transform@^0.10.0: + version "0.10.1" + resolved "https://registry.npmjs.org/regenerator-transform/-/regenerator-transform-0.10.1.tgz" + integrity sha512-PJepbvDbuK1xgIgnau7Y90cwaAmO/LCLMI2mPvaXq2heGMR3aWW5/BQvYrhJ8jgmQjXewXvBjzfqKcVOmhjZ6Q== + dependencies: + babel-runtime "^6.18.0" + babel-types "^6.19.0" + private "^0.1.6" + +regex-not@^1.0.0, regex-not@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/regex-not/-/regex-not-1.0.2.tgz" + integrity sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A== + dependencies: + extend-shallow "^3.0.2" + safe-regex "^1.1.0" + +regexp.prototype.flags@^1.2.0, regexp.prototype.flags@^1.4.1: + version "1.4.3" + resolved "https://registry.yarnpkg.com/regexp.prototype.flags/-/regexp.prototype.flags-1.4.3.tgz#87cab30f80f66660181a3bb7bf5981a872b367ac" + integrity sha512-fjggEOO3slI6Wvgjwflkc4NFRCTZAu5CnNfBd5qOMYhWdn67nJBBu34/TkD++eeFmd8C9r9jfXJ27+nSiRkSUA== + dependencies: + call-bind "^1.0.2" + define-properties "^1.1.3" + functions-have-names "^1.2.2" + +regexpp@^2.0.1: + version "2.0.1" + resolved "https://registry.npmjs.org/regexpp/-/regexpp-2.0.1.tgz" + integrity sha512-lv0M6+TkDVniA3aD1Eg0DVpfU/booSu7Eev3TDO/mZKHBfVjgCGTV4t4buppESEYDtkArYFOxTJWv6S5C+iaNw== + +regexpp@^3.0.0, regexpp@^3.2.0: + version "3.2.0" + resolved "https://registry.npmjs.org/regexpp/-/regexpp-3.2.0.tgz" + integrity sha512-pq2bWo9mVD43nbts2wGv17XLiNLya+GklZ8kaDLV2Z08gDCsGpnKn9BFMepvWuHCbyVvY7J5o5+BVvoQbmlJLg== + +regexpu-core@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/regexpu-core/-/regexpu-core-2.0.0.tgz" + integrity sha1-SdA4g3uNz4v6W5pCE5k45uoq4kA= + dependencies: + regenerate "^1.2.1" + regjsgen "^0.2.0" + regjsparser "^0.1.4" + +regjsgen@^0.2.0: + version "0.2.0" + resolved "https://registry.npmjs.org/regjsgen/-/regjsgen-0.2.0.tgz" + integrity sha1-bAFq3qxVT3WCP+N6wFuS1aTtsfc= + +regjsparser@^0.1.4: + version "0.1.5" + resolved "https://registry.npmjs.org/regjsparser/-/regjsparser-0.1.5.tgz" + integrity sha1-fuj4Tcb6eS0/0K4ijSS9lJ6tIFw= + dependencies: + jsesc "~0.5.0" + +repeat-element@^1.1.2: + version "1.1.4" + resolved "https://registry.yarnpkg.com/repeat-element/-/repeat-element-1.1.4.tgz#be681520847ab58c7568ac75fbfad28ed42d39e9" + integrity sha512-LFiNfRcSu7KK3evMyYOuCzv3L10TW7yC1G2/+StMjK8Y6Vqd2MG7r/Qjw4ghtuCOjFvlnms/iMmLqpvW/ES/WQ== + +repeat-string@^1.6.1: + version "1.6.1" + resolved "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz" + integrity sha1-jcrkcOHIirwtYA//Sndihtp15jc= + +repeating@^2.0.0: + version "2.0.1" + resolved "https://registry.npmjs.org/repeating/-/repeating-2.0.1.tgz" + integrity sha1-UhTFOpJtNVJwdSf7q0FdvAjQbdo= + dependencies: + is-finite "^1.0.0" + +req-cwd@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/req-cwd/-/req-cwd-2.0.0.tgz" + integrity sha1-1AgrTURZgDZkD7c93qAe1T20nrw= + dependencies: + req-from "^2.0.0" + +req-from@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/req-from/-/req-from-2.0.0.tgz" + integrity sha1-10GI5H+TeW9Kpx327jWuaJ8+DnA= + dependencies: + resolve-from "^3.0.0" + +request-promise-core@1.1.4: + version "1.1.4" + resolved "https://registry.npmjs.org/request-promise-core/-/request-promise-core-1.1.4.tgz" + integrity sha512-TTbAfBBRdWD7aNNOoVOBH4pN/KigV6LyapYNNlAPA8JwbovRti1E88m3sYAwsLi5ryhPKsE9APwnjFTgdUjTpw== + dependencies: + lodash "^4.17.19" + +request-promise-native@^1.0.5: + version "1.0.9" + resolved "https://registry.npmjs.org/request-promise-native/-/request-promise-native-1.0.9.tgz" + integrity sha512-wcW+sIUiWnKgNY0dqCpOZkUbF/I+YPi+f09JZIDa39Ec+q82CpSYniDp+ISgTTbKmnpJWASeJBPZmoxH84wt3g== + dependencies: + request-promise-core "1.1.4" + stealthy-require "^1.1.1" + tough-cookie "^2.3.3" + +request@^2.79.0, request@^2.85.0, request@^2.88.0: + version "2.88.2" + resolved "https://registry.npmjs.org/request/-/request-2.88.2.tgz" + integrity sha512-MsvtOrfG9ZcrOwAW+Qi+F6HbD0CWXEh9ou77uOb7FM2WPhwT7smM833PzanhJLsgXjN89Ir6V2PczXNnMpwKhw== + dependencies: + aws-sign2 "~0.7.0" + aws4 "^1.8.0" + caseless "~0.12.0" + combined-stream "~1.0.6" + extend "~3.0.2" + forever-agent "~0.6.1" + form-data "~2.3.2" + har-validator "~5.1.3" + http-signature "~1.2.0" + is-typedarray "~1.0.0" + isstream "~0.1.2" + json-stringify-safe "~5.0.1" + mime-types "~2.1.19" + oauth-sign "~0.9.0" + performance-now "^2.1.0" + qs "~6.5.2" + safe-buffer "^5.1.2" + tough-cookie "~2.5.0" + tunnel-agent "^0.6.0" + uuid "^3.3.2" + +require-directory@^2.1.1: + version "2.1.1" + resolved "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz" + integrity sha1-jGStX9MNqxyXbiNE/+f3kqam30I= + +require-from-string@^1.1.0: + version "1.2.1" + resolved "https://registry.npmjs.org/require-from-string/-/require-from-string-1.2.1.tgz" + integrity sha1-UpyczvJzgK3+yaL5ZbZJu+5jZBg= + +require-from-string@^2.0.0, require-from-string@^2.0.2: + version "2.0.2" + resolved "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz" + integrity sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw== + +require-main-filename@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/require-main-filename/-/require-main-filename-1.0.1.tgz" + integrity sha1-l/cXtp1IeE9fUmpsWqj/3aBVpNE= + +require-main-filename@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/require-main-filename/-/require-main-filename-2.0.0.tgz" + integrity sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg== + +resolve-from@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/resolve-from/-/resolve-from-3.0.0.tgz" + integrity sha1-six699nWiBvItuZTM17rywoYh0g= + +resolve-from@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz" + integrity sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g== + +resolve-url@^0.2.1: + version "0.2.1" + resolved "https://registry.npmjs.org/resolve-url/-/resolve-url-0.2.1.tgz" + integrity sha1-LGN/53yJOv0qZj/iGqkIAGjiBSo= + +resolve@1.1.x: + version "1.1.7" + resolved "https://registry.npmjs.org/resolve/-/resolve-1.1.7.tgz" + integrity sha1-IDEU2CrSxe2ejgQRs5ModeiJ6Xs= + +resolve@1.17.0: + version "1.17.0" + resolved "https://registry.npmjs.org/resolve/-/resolve-1.17.0.tgz" + integrity sha512-ic+7JYiV8Vi2yzQGFWOkiZD5Z9z7O2Zhm9XMaTxdJExKasieFCr+yXZ/WmXsckHiKl12ar0y6XiXDx3m4RHn1w== + dependencies: + path-parse "^1.0.6" + +resolve@^1.1.6, resolve@^1.10.0, resolve@^1.10.1, resolve@^1.20.0, resolve@^1.22.0, resolve@^1.8.1, resolve@~1.22.0: + version "1.22.0" + resolved "https://registry.npmjs.org/resolve/-/resolve-1.22.0.tgz" + integrity sha512-Hhtrw0nLeSrFQ7phPp4OOcVjLPIeMnRlr5mcnVuMe7M/7eBn98A3hmFRLoFo3DLZkivSYwhRUJTyPyWAk56WLw== + dependencies: + is-core-module "^2.8.1" + path-parse "^1.0.7" + supports-preserve-symlinks-flag "^1.0.0" + +responselike@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/responselike/-/responselike-1.0.2.tgz" + integrity sha1-kYcg7ztjHFZCvgaPFa3lpG9Loec= + dependencies: + lowercase-keys "^1.0.0" + +restore-cursor@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/restore-cursor/-/restore-cursor-2.0.0.tgz" + integrity sha1-n37ih/gv0ybU/RYpI9YhKe7g368= + dependencies: + onetime "^2.0.0" + signal-exit "^3.0.2" + +restore-cursor@^3.1.0: + version "3.1.0" + resolved "https://registry.npmjs.org/restore-cursor/-/restore-cursor-3.1.0.tgz" + integrity sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA== + dependencies: + onetime "^5.1.0" + signal-exit "^3.0.2" + +resumer@~0.0.0: + version "0.0.0" + resolved "https://registry.npmjs.org/resumer/-/resumer-0.0.0.tgz" + integrity sha1-8ej0YeQGS6Oegq883CqMiT0HZ1k= + dependencies: + through "~2.3.4" + +ret@~0.1.10: + version "0.1.15" + resolved "https://registry.npmjs.org/ret/-/ret-0.1.15.tgz" + integrity sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg== + +retry@^0.12.0: + version "0.12.0" + resolved "https://registry.yarnpkg.com/retry/-/retry-0.12.0.tgz#1b42a6266a21f07421d1b0b54b7dc167b01c013b" + integrity sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow== + +reusify@^1.0.4: + version "1.0.4" + resolved "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz" + integrity sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw== + +rfdc@^1.3.0: + version "1.3.0" + resolved "https://registry.npmjs.org/rfdc/-/rfdc-1.3.0.tgz" + integrity sha512-V2hovdzFbOi77/WajaSMXk2OLm+xNIeQdMMuB7icj7bk6zi2F8GGAxigcnDFpJHbNyNcgyJDiP+8nOrY5cZGrA== + +rimraf@2.6.3: + version "2.6.3" + resolved "https://registry.npmjs.org/rimraf/-/rimraf-2.6.3.tgz" + integrity sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA== + dependencies: + glob "^7.1.3" + +rimraf@^2.2.8, rimraf@^2.6.3: + version "2.7.1" + resolved "https://registry.npmjs.org/rimraf/-/rimraf-2.7.1.tgz" + integrity sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w== + dependencies: + glob "^7.1.3" + +rimraf@^3.0.2: + version "3.0.2" + resolved "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz" + integrity sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA== + dependencies: + glob "^7.1.3" + +ripemd160@^2.0.0, ripemd160@^2.0.1: + version "2.0.2" + resolved "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.2.tgz" + integrity sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA== + dependencies: + hash-base "^3.0.0" + inherits "^2.0.1" + +rlp@^2.0.0, rlp@^2.2.1, rlp@^2.2.2, rlp@^2.2.3, rlp@^2.2.4: + version "2.2.7" + resolved "https://registry.npmjs.org/rlp/-/rlp-2.2.7.tgz" + integrity sha512-d5gdPmgQ0Z+AklL2NVXr/IoSjNZFfTVvQWzL/AM2AOcSzYP2xjlb0AC8YyCLc41MSNf6P6QVtjgPdmVtzb+4lQ== + dependencies: + bn.js "^5.2.0" + +run-async@^2.2.0: + version "2.4.1" + resolved "https://registry.npmjs.org/run-async/-/run-async-2.4.1.tgz" + integrity sha512-tvVnVv01b8c1RrA6Ep7JkStj85Guv/YrMcwqYQnwjsAS2cTmmPGBBjAjpCW7RrSodNSoE2/qg9O4bceNvUuDgQ== + +run-parallel@^1.1.9: + version "1.2.0" + resolved "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz" + integrity sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA== + dependencies: + queue-microtask "^1.2.2" + +rustbn.js@~0.2.0: + version "0.2.0" + resolved "https://registry.npmjs.org/rustbn.js/-/rustbn.js-0.2.0.tgz" + integrity sha512-4VlvkRUuCJvr2J6Y0ImW7NvTCriMi7ErOAqWk1y69vAdoNIzCF3yPmgeNzx+RQTLEDFq5sHfscn1MwHxP9hNfA== + +rxjs@^6.4.0: + version "6.6.7" + resolved "https://registry.npmjs.org/rxjs/-/rxjs-6.6.7.tgz" + integrity sha512-hTdwr+7yYNIT5n4AMYp85KA6yw2Va0FLa3Rguvbpa4W3I5xynaBZo41cM3XM+4Q6fRMj3sBYIR1VAmZMXYJvRQ== + dependencies: + tslib "^1.9.0" + +rxjs@^7.5.5: + version "7.5.5" + resolved "https://registry.npmjs.org/rxjs/-/rxjs-7.5.5.tgz" + integrity sha512-sy+H0pQofO95VDmFLzyaw9xNJU4KTRSwQIGM6+iG3SypAtCiLDzpeG8sJrNCWn2Up9km+KhkvTdbkrdy+yzZdw== + dependencies: + tslib "^2.1.0" + +safe-buffer@5.2.1, safe-buffer@^5.0.1, safe-buffer@^5.1.0, safe-buffer@^5.1.1, safe-buffer@^5.1.2, safe-buffer@^5.2.0, safe-buffer@^5.2.1, safe-buffer@~5.2.0: + version "5.2.1" + resolved "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz" + integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ== + +safe-buffer@~5.1.0, safe-buffer@~5.1.1: + version "5.1.2" + resolved "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz" + integrity sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g== + +safe-event-emitter@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/safe-event-emitter/-/safe-event-emitter-1.0.1.tgz" + integrity sha512-e1wFe99A91XYYxoQbcq2ZJUWurxEyP8vfz7A7vuUe1s95q8r5ebraVaA1BukYJcpM6V16ugWoD9vngi8Ccu5fg== + dependencies: + events "^3.0.0" + +safe-regex@^1.1.0: + version "1.1.0" + resolved "https://registry.npmjs.org/safe-regex/-/safe-regex-1.1.0.tgz" + integrity sha1-QKNmnzsHfR6UPURinhV91IAjvy4= + dependencies: + ret "~0.1.10" + +"safer-buffer@>= 2.1.2 < 3", safer-buffer@^2.0.2, safer-buffer@^2.1.0, safer-buffer@~2.1.0: + version "2.1.2" + resolved "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz" + integrity sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg== + +sc-istanbul@^0.4.5: + version "0.4.6" + resolved "https://registry.npmjs.org/sc-istanbul/-/sc-istanbul-0.4.6.tgz" + integrity sha512-qJFF/8tW/zJsbyfh/iT/ZM5QNHE3CXxtLJbZsL+CzdJLBsPD7SedJZoUA4d8iAcN2IoMp/Dx80shOOd2x96X/g== + dependencies: + abbrev "1.0.x" + async "1.x" + escodegen "1.8.x" + esprima "2.7.x" + glob "^5.0.15" + handlebars "^4.0.1" + js-yaml "3.x" + mkdirp "0.5.x" + nopt "3.x" + once "1.x" + resolve "1.1.x" + supports-color "^3.1.0" + which "^1.1.1" + wordwrap "^1.0.0" + +scrypt-js@2.0.4: + version "2.0.4" + resolved "https://registry.npmjs.org/scrypt-js/-/scrypt-js-2.0.4.tgz" + integrity sha512-4KsaGcPnuhtCZQCxFxN3GVYIhKFPTdLd8PLC552XwbMndtD0cjRFAhDuuydXQ0h08ZfPgzqe6EKHozpuH74iDw== + +scrypt-js@3.0.1, scrypt-js@^3.0.0, scrypt-js@^3.0.1: + version "3.0.1" + resolved "https://registry.npmjs.org/scrypt-js/-/scrypt-js-3.0.1.tgz" + integrity sha512-cdwTTnqPu0Hyvf5in5asVdZocVDTNRmR7XEcJuIzMjJeSHybHl7vpB66AzwTaIg6CLSbtjcxc8fqcySfnTkccA== + +scryptsy@^1.2.1: + version "1.2.1" + resolved "https://registry.npmjs.org/scryptsy/-/scryptsy-1.2.1.tgz" + integrity sha1-oyJfpLJST4AnAHYeKFW987LZIWM= + dependencies: + pbkdf2 "^3.0.3" + +scuffed-abi@^1.0.4: + version "1.0.4" + resolved "https://registry.yarnpkg.com/scuffed-abi/-/scuffed-abi-1.0.4.tgz#bc88129877856de5026d8afaea49de9a1972b6cf" + integrity sha512-1NN2L1j+TMF6+/J2jHcAnhPH8Lwaqu5dlgknZPqejEVFQ8+cvcnXYNbaHtGEXTjSNrQLBGePXicD4oFGqecOnQ== + +"seaport@git+https://github.com/ProjectOpenSea/seaport.git#5c6a628cb152d731e956682dd748d30e8bf1f1c9": + version "1.1.0" + resolved "git+https://github.com/ProjectOpenSea/seaport.git#5c6a628cb152d731e956682dd748d30e8bf1f1c9" + dependencies: + ethers "^5.5.3" + ethers-eip712 "^0.2.0" + hardhat "https://github.com/0age/hardhat/releases/download/viaIR-2.9.3/hardhat-v2.9.3.tgz" + +secp256k1@^4.0.1: + version "4.0.3" + resolved "https://registry.npmjs.org/secp256k1/-/secp256k1-4.0.3.tgz" + integrity sha512-NLZVf+ROMxwtEj3Xa562qgv2BK5e2WNmXPiOdVIPLgs6lyTzMvBq0aWTYMI5XCP9jZMVKOcqZLw/Wc4vDkuxhA== + dependencies: + elliptic "^6.5.4" + node-addon-api "^2.0.0" + node-gyp-build "^4.2.0" + +seedrandom@3.0.1: + version "3.0.1" + resolved "https://registry.npmjs.org/seedrandom/-/seedrandom-3.0.1.tgz" + integrity sha512-1/02Y/rUeU1CJBAGLebiC5Lbo5FnB22gQbIFFYTLkwvp1xdABZJH1sn4ZT1MzXmPpzv+Rf/Lu2NcsLJiK4rcDg== + +semaphore-async-await@^1.5.1: + version "1.5.1" + resolved "https://registry.npmjs.org/semaphore-async-await/-/semaphore-async-await-1.5.1.tgz" + integrity sha1-hXvvXjZEYBykuVcLh+nfXKEpdPo= + +semaphore@>=1.0.1, semaphore@^1.0.3, semaphore@^1.1.0: + version "1.1.0" + resolved "https://registry.npmjs.org/semaphore/-/semaphore-1.1.0.tgz" + integrity sha512-O4OZEaNtkMd/K0i6js9SL+gqy0ZCBMgUvlSqHKi4IBdjhe7wB8pwztUk1BbZ1fmrvpwFrPbHzqd2w5pTcJH6LA== + +"semver@2 || 3 || 4 || 5", semver@^5.3.0, semver@^5.5.0, semver@^5.5.1, semver@^5.6.0, semver@^5.7.0: + version "5.7.1" + resolved "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz" + integrity sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ== + +semver@^6.3.0: + version "6.3.0" + resolved "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz" + integrity sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw== + +semver@^7.0.0, semver@^7.3.4, semver@^7.3.5, semver@^7.3.7: + version "7.3.7" + resolved "https://registry.npmjs.org/semver/-/semver-7.3.7.tgz" + integrity sha512-QlYTucUYOews+WeEujDoEGziz4K6c47V/Bd+LjSSYcA94p+DmINdf7ncaUinThfvZyu13lN9OY1XDxt8C0Tw0g== + dependencies: + lru-cache "^6.0.0" + +semver@~5.4.1: + version "5.4.1" + resolved "https://registry.npmjs.org/semver/-/semver-5.4.1.tgz" + integrity sha512-WfG/X9+oATh81XtllIo/I8gOiY9EXRdv1cQdyykeXK17YcUW3EXUAi2To4pcH6nZtJPr7ZOpM5OMyWJZm+8Rsg== + +send@0.18.0: + version "0.18.0" + resolved "https://registry.npmjs.org/send/-/send-0.18.0.tgz" + integrity sha512-qqWzuOjSFOuqPjFe4NOsMLafToQQwBSOEpS+FwEt3A2V3vKubTquT3vmLTQpFgMXp8AlFWFuP1qKaJZOtPpVXg== + dependencies: + debug "2.6.9" + depd "2.0.0" + destroy "1.2.0" + encodeurl "~1.0.2" + escape-html "~1.0.3" + etag "~1.8.1" + fresh "0.5.2" + http-errors "2.0.0" + mime "1.6.0" + ms "2.1.3" + on-finished "2.4.1" + range-parser "~1.2.1" + statuses "2.0.1" + +serialize-javascript@6.0.0: + version "6.0.0" + resolved "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.0.tgz" + integrity sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag== + dependencies: + randombytes "^2.1.0" + +serve-static@1.15.0: + version "1.15.0" + resolved "https://registry.npmjs.org/serve-static/-/serve-static-1.15.0.tgz" + integrity sha512-XGuRDNjXUijsUL0vl6nSD7cwURuzEgglbOaFuZM9g3kwDXOWVTck0jLzjPzGD+TazWbboZYu52/9/XPdUgne9g== + dependencies: + encodeurl "~1.0.2" + escape-html "~1.0.3" + parseurl "~1.3.3" + send "0.18.0" + +servify@^0.1.12: + version "0.1.12" + resolved "https://registry.npmjs.org/servify/-/servify-0.1.12.tgz" + integrity sha512-/xE6GvsKKqyo1BAY+KxOWXcLpPsUUyji7Qg3bVD7hh1eRze5bR1uYiuDA/k3Gof1s9BTzQZEJK8sNcNGFIzeWw== + dependencies: + body-parser "^1.16.0" + cors "^2.8.1" + express "^4.14.0" + request "^2.79.0" + xhr "^2.3.3" + +set-blocking@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz" + integrity sha1-BF+XgtARrppoA93TgrJDkrPYkPc= + +set-immediate-shim@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/set-immediate-shim/-/set-immediate-shim-1.0.1.tgz" + integrity sha1-SysbJ+uAip+NzEgaWOXlb1mfP2E= + +set-value@^2.0.0, set-value@^2.0.1: + version "2.0.1" + resolved "https://registry.npmjs.org/set-value/-/set-value-2.0.1.tgz" + integrity sha512-JxHc1weCN68wRY0fhCoXpyK55m/XPHafOmK4UWD7m2CI14GMcFypt4w/0+NV5f/ZMby2F6S2wwA7fgynh9gWSw== + dependencies: + extend-shallow "^2.0.1" + is-extendable "^0.1.1" + is-plain-object "^2.0.3" + split-string "^3.0.1" + +setimmediate@1.0.4: + version "1.0.4" + resolved "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.4.tgz" + integrity sha1-IOgd5iLUoCWIzgyNqJc8vPHTE48= + +setimmediate@^1.0.5: + version "1.0.5" + resolved "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.5.tgz" + integrity sha1-KQy7Iy4waULX1+qbg3Mqt4VvgoU= + +setprototypeof@1.2.0: + version "1.2.0" + resolved "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz" + integrity sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw== + +sha.js@^2.4.0, sha.js@^2.4.8: + version "2.4.11" + resolved "https://registry.npmjs.org/sha.js/-/sha.js-2.4.11.tgz" + integrity sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ== + dependencies: + inherits "^2.0.1" + safe-buffer "^5.0.1" + +sha1@^1.1.1: + version "1.1.1" + resolved "https://registry.npmjs.org/sha1/-/sha1-1.1.1.tgz" + integrity sha1-rdqnqTFo85PxnrKxUJFhjicA+Eg= + dependencies: + charenc ">= 0.0.1" + crypt ">= 0.0.1" + +shebang-command@^1.2.0: + version "1.2.0" + resolved "https://registry.npmjs.org/shebang-command/-/shebang-command-1.2.0.tgz" + integrity sha1-RKrGW2lbAzmJaMOfNj/uXer98eo= + dependencies: + shebang-regex "^1.0.0" + +shebang-command@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz" + integrity sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA== + dependencies: + shebang-regex "^3.0.0" + +shebang-regex@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/shebang-regex/-/shebang-regex-1.0.0.tgz" + integrity sha1-2kL0l0DAtC2yypcoVxyxkMmO/qM= + +shebang-regex@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz" + integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A== + +shelljs@^0.8.3: + version "0.8.5" + resolved "https://registry.npmjs.org/shelljs/-/shelljs-0.8.5.tgz" + integrity sha512-TiwcRcrkhHvbrZbnRcFYMLl30Dfov3HKqzp5tO5b4pt6G/SezKcYhmDg15zXVBswHmctSAQKznqNW2LO5tTDow== + dependencies: + glob "^7.0.0" + interpret "^1.0.0" + rechoir "^0.6.2" + +side-channel@^1.0.4: + version "1.0.4" + resolved "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz" + integrity sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw== + dependencies: + call-bind "^1.0.0" + get-intrinsic "^1.0.2" + object-inspect "^1.9.0" + +signal-exit@^3.0.2, signal-exit@^3.0.3: + version "3.0.7" + resolved "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz" + integrity sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ== + +simple-concat@^1.0.0: + version "1.0.1" + resolved "https://registry.npmjs.org/simple-concat/-/simple-concat-1.0.1.tgz" + integrity sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q== + +simple-get@^2.7.0: + version "2.8.2" + resolved "https://registry.npmjs.org/simple-get/-/simple-get-2.8.2.tgz" + integrity sha512-Ijd/rV5o+mSBBs4F/x9oDPtTx9Zb6X9brmnXvMW4J7IR15ngi9q5xxqWBKU744jTZiaXtxaPL7uHG6vtN8kUkw== + dependencies: + decompress-response "^3.3.0" + once "^1.3.1" + simple-concat "^1.0.0" + +slash@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/slash/-/slash-1.0.0.tgz" + integrity sha1-xB8vbDn8FtHNF61LXYlhFK5HDVU= + +slash@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/slash/-/slash-2.0.0.tgz" + integrity sha512-ZYKh3Wh2z1PpEXWr0MpSBZ0V6mZHAQfYevttO11c51CaWjGTaadiKZ+wVt1PbMlDV5qhMFslpZCemhwOK7C89A== + +slash@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz" + integrity sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q== + +slice-ansi@^2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/slice-ansi/-/slice-ansi-2.1.0.tgz" + integrity sha512-Qu+VC3EwYLldKa1fCxuuvULvSJOKEgk9pi8dZeCVK7TqBfUNTH4sFkk4joj8afVSfAYgJoSOetjx9QWOJ5mYoQ== + dependencies: + ansi-styles "^3.2.0" + astral-regex "^1.0.0" + is-fullwidth-code-point "^2.0.0" + +slice-ansi@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/slice-ansi/-/slice-ansi-3.0.0.tgz" + integrity sha512-pSyv7bSTC7ig9Dcgbw9AuRNUb5k5V6oDudjZoMBSr13qpLBG7tB+zgCkARjq7xIUgdz5P1Qe8u+rSGdouOOIyQ== + dependencies: + ansi-styles "^4.0.0" + astral-regex "^2.0.0" + is-fullwidth-code-point "^3.0.0" + +slice-ansi@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/slice-ansi/-/slice-ansi-4.0.0.tgz" + integrity sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ== + dependencies: + ansi-styles "^4.0.0" + astral-regex "^2.0.0" + is-fullwidth-code-point "^3.0.0" + +slice-ansi@^5.0.0: + version "5.0.0" + resolved "https://registry.npmjs.org/slice-ansi/-/slice-ansi-5.0.0.tgz" + integrity sha512-FC+lgizVPfie0kkhqUScwRu1O/lF6NOgJmlCgK+/LYxDCTk8sGelYaHDhFcDN+Sn3Cv+3VSa4Byeo+IMCzpMgQ== + dependencies: + ansi-styles "^6.0.0" + is-fullwidth-code-point "^4.0.0" + +snapdragon-node@^2.0.1: + version "2.1.1" + resolved "https://registry.npmjs.org/snapdragon-node/-/snapdragon-node-2.1.1.tgz" + integrity sha512-O27l4xaMYt/RSQ5TR3vpWCAB5Kb/czIcqUFOM/C4fYcLnbZUc1PkjTAMjof2pBWaSTwOUd6qUHcFGVGj7aIwnw== + dependencies: + define-property "^1.0.0" + isobject "^3.0.0" + snapdragon-util "^3.0.1" + +snapdragon-util@^3.0.1: + version "3.0.1" + resolved "https://registry.npmjs.org/snapdragon-util/-/snapdragon-util-3.0.1.tgz" + integrity sha512-mbKkMdQKsjX4BAL4bRYTj21edOf8cN7XHdYUJEe+Zn99hVEYcMvKPct1IqNe7+AZPirn8BCDOQBHQZknqmKlZQ== + dependencies: + kind-of "^3.2.0" + +snapdragon@^0.8.1: + version "0.8.2" + resolved "https://registry.npmjs.org/snapdragon/-/snapdragon-0.8.2.tgz" + integrity sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg== + dependencies: + base "^0.11.1" + debug "^2.2.0" + define-property "^0.2.5" + extend-shallow "^2.0.1" + map-cache "^0.2.2" + source-map "^0.5.6" + source-map-resolve "^0.5.0" + use "^3.1.0" + +solc@0.7.3: + version "0.7.3" + resolved "https://registry.npmjs.org/solc/-/solc-0.7.3.tgz" + integrity sha512-GAsWNAjGzIDg7VxzP6mPjdurby3IkGCjQcM8GFYZT6RyaoUZKmMU6Y7YwG+tFGhv7dwZ8rmR4iwFDrrD99JwqA== + dependencies: + command-exists "^1.2.8" + commander "3.0.2" + follow-redirects "^1.12.1" + fs-extra "^0.30.0" + js-sha3 "0.8.0" + memorystream "^0.3.1" + require-from-string "^2.0.0" + semver "^5.5.0" + tmp "0.0.33" + +solc@^0.4.20: + version "0.4.26" + resolved "https://registry.npmjs.org/solc/-/solc-0.4.26.tgz" + integrity sha512-o+c6FpkiHd+HPjmjEVpQgH7fqZ14tJpXhho+/bQXlXbliLIS/xjXb42Vxh+qQY1WCSTMQ0+a5vR9vi0MfhU6mA== + dependencies: + fs-extra "^0.30.0" + memorystream "^0.3.1" + require-from-string "^1.1.0" + semver "^5.3.0" + yargs "^4.7.1" + +solc@^0.6.3: + version "0.6.12" + resolved "https://registry.npmjs.org/solc/-/solc-0.6.12.tgz" + integrity sha512-Lm0Ql2G9Qc7yPP2Ba+WNmzw2jwsrd3u4PobHYlSOxaut3TtUbj9+5ZrT6f4DUpNPEoBaFUOEg9Op9C0mk7ge9g== + dependencies: + command-exists "^1.2.8" + commander "3.0.2" + fs-extra "^0.30.0" + js-sha3 "0.8.0" + memorystream "^0.3.1" + require-from-string "^2.0.0" + semver "^5.5.0" + tmp "0.0.33" + +solhint@^3.3.6: + version "3.3.7" + resolved "https://registry.npmjs.org/solhint/-/solhint-3.3.7.tgz" + integrity sha512-NjjjVmXI3ehKkb3aNtRJWw55SUVJ8HMKKodwe0HnejA+k0d2kmhw7jvpa+MCTbcEgt8IWSwx0Hu6aCo/iYOZzQ== + dependencies: + "@solidity-parser/parser" "^0.14.1" + ajv "^6.6.1" + antlr4 "4.7.1" + ast-parents "0.0.1" + chalk "^2.4.2" + commander "2.18.0" + cosmiconfig "^5.0.7" + eslint "^5.6.0" + fast-diff "^1.1.2" + glob "^7.1.3" + ignore "^4.0.6" + js-yaml "^3.12.0" + lodash "^4.17.11" + semver "^6.3.0" + optionalDependencies: + prettier "^1.14.3" + +solidity-ast@^0.4.15: + version "0.4.35" + resolved "https://registry.yarnpkg.com/solidity-ast/-/solidity-ast-0.4.35.tgz#82e064b14dc989338123264bde2235cad751f128" + integrity sha512-F5bTDLh3rmDxRmLSrs3qt3nvxJprWSEkS7h2KmuXDx7XTfJ6ZKVTV1rtPIYCqJAuPsU/qa8YUeFn7jdOAZcTPA== + +solidity-comments-extractor@^0.0.7: + version "0.0.7" + resolved "https://registry.npmjs.org/solidity-comments-extractor/-/solidity-comments-extractor-0.0.7.tgz" + integrity sha512-wciNMLg/Irp8OKGrh3S2tfvZiZ0NEyILfcRCXCD4mp7SgK/i9gzLfhY2hY7VMCQJ3kH9UB9BzNdibIVMchzyYw== + +solidity-coverage@^0.7.0: + version "0.7.21" + resolved "https://registry.npmjs.org/solidity-coverage/-/solidity-coverage-0.7.21.tgz" + integrity sha512-O8nuzJ9yXiKUx3NdzVvHrUW0DxoNVcGzq/I7NzewNO9EZE3wYAQ4l8BwcnV64r4aC/HB6Vnw/q2sF0BQHv/3fg== + dependencies: + "@solidity-parser/parser" "^0.14.0" + "@truffle/provider" "^0.2.24" + chalk "^2.4.2" + death "^1.1.0" + detect-port "^1.3.0" + fs-extra "^8.1.0" + ghost-testrpc "^0.0.2" + global-modules "^2.0.0" + globby "^10.0.1" + jsonschema "^1.2.4" + lodash "^4.17.15" + node-emoji "^1.10.0" + pify "^4.0.1" + recursive-readdir "^2.2.2" + sc-istanbul "^0.4.5" + semver "^7.3.4" + shelljs "^0.8.3" + web3-utils "^1.3.0" + +source-map-resolve@^0.5.0: + version "0.5.3" + resolved "https://registry.npmjs.org/source-map-resolve/-/source-map-resolve-0.5.3.tgz" + integrity sha512-Htz+RnsXWk5+P2slx5Jh3Q66vhQj1Cllm0zvnaY98+NFx+Dv2CF/f5O/t8x+KaNdrdIAsruNzoh/KpialbqAnw== + dependencies: + atob "^2.1.2" + decode-uri-component "^0.2.0" + resolve-url "^0.2.1" + source-map-url "^0.4.0" + urix "^0.1.0" + +source-map-support@0.5.12: + version "0.5.12" + resolved "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.12.tgz" + integrity sha512-4h2Pbvyy15EE02G+JOZpUCmqWJuqrs+sEkzewTm++BPi7Hvn/HwcqLAcNxYAyI0x13CpPPn+kMjl+hplXMHITQ== + dependencies: + buffer-from "^1.0.0" + source-map "^0.6.0" + +source-map-support@^0.4.15: + version "0.4.18" + resolved "https://registry.npmjs.org/source-map-support/-/source-map-support-0.4.18.tgz" + integrity sha512-try0/JqxPLF9nOjvSta7tVondkP5dwgyLDjVoyMDlmjugT2lRZ1OfsrYTkCd2hkDnJTKRbO/Rl3orm8vlsUzbA== + dependencies: + source-map "^0.5.6" + +source-map-support@^0.5.13: + version "0.5.21" + resolved "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz" + integrity sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w== + dependencies: + buffer-from "^1.0.0" + source-map "^0.6.0" + +source-map-url@^0.4.0: + version "0.4.1" + resolved "https://registry.yarnpkg.com/source-map-url/-/source-map-url-0.4.1.tgz#0af66605a745a5a2f91cf1bbf8a7afbc283dec56" + integrity sha512-cPiFOTLUKvJFIg4SKVScy4ilPPW6rFgMgfuZJPNoDuMs3nC1HbMUycBoJw77xFIp6z1UJQJOfx6C9GMH80DiTw== + +source-map@^0.5.6, source-map@^0.5.7: + version "0.5.7" + resolved "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz" + integrity sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w= + +source-map@^0.6.0, source-map@^0.6.1: + version "0.6.1" + resolved "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz" + integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g== + +source-map@~0.2.0: + version "0.2.0" + resolved "https://registry.npmjs.org/source-map/-/source-map-0.2.0.tgz" + integrity sha1-2rc/vPwrqBm03gO9b26qSBZLP50= + dependencies: + amdefine ">=0.0.4" + +spdx-correct@^3.0.0: + version "3.1.1" + resolved "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.1.1.tgz" + integrity sha512-cOYcUWwhCuHCXi49RhFRCyJEK3iPj1Ziz9DpViV3tbZOwXD49QzIN3MpOLJNxh2qwq2lJJZaKMVw9qNi4jTC0w== + dependencies: + spdx-expression-parse "^3.0.0" + spdx-license-ids "^3.0.0" + +spdx-exceptions@^2.1.0: + version "2.3.0" + resolved "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.3.0.tgz" + integrity sha512-/tTrYOC7PPI1nUAgx34hUpqXuyJG+DTHJTnIULG4rDygi4xu/tfgmq1e1cIRwRzwZgo4NLySi+ricLkZkw4i5A== + +spdx-expression-parse@^3.0.0: + version "3.0.1" + resolved "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz" + integrity sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q== + dependencies: + spdx-exceptions "^2.1.0" + spdx-license-ids "^3.0.0" + +spdx-license-ids@^3.0.0: + version "3.0.11" + resolved "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.11.tgz" + integrity sha512-Ctl2BrFiM0X3MANYgj3CkygxhRmr9mi6xhejbdO960nF6EDJApTYpn0BQnDKlnNBULKiCN1n3w9EBkHK8ZWg+g== + +split-string@^3.0.1, split-string@^3.0.2: + version "3.1.0" + resolved "https://registry.npmjs.org/split-string/-/split-string-3.1.0.tgz" + integrity sha512-NzNVhJDYpwceVVii8/Hu6DKfD2G+NrQHlS/V/qgv763EYudVwEcMQNxd2lh+0VrUByXN/oJkl5grOhYWvQUYiw== + dependencies: + extend-shallow "^3.0.0" + +sprintf-js@~1.0.2: + version "1.0.3" + resolved "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz" + integrity sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw= + +sshpk@^1.7.0: + version "1.17.0" + resolved "https://registry.npmjs.org/sshpk/-/sshpk-1.17.0.tgz" + integrity sha512-/9HIEs1ZXGhSPE8X6Ccm7Nam1z8KcoCqPdI7ecm1N33EzAetWahvQWVqLZtaZQ+IDKX4IyA2o0gBzqIMkAagHQ== + dependencies: + asn1 "~0.2.3" + assert-plus "^1.0.0" + bcrypt-pbkdf "^1.0.0" + dashdash "^1.12.0" + ecc-jsbn "~0.1.1" + getpass "^0.1.1" + jsbn "~0.1.0" + safer-buffer "^2.0.2" + tweetnacl "~0.14.0" + +stacktrace-parser@^0.1.10: + version "0.1.10" + resolved "https://registry.npmjs.org/stacktrace-parser/-/stacktrace-parser-0.1.10.tgz" + integrity sha512-KJP1OCML99+8fhOHxwwzyWrlUuVX5GQ0ZpJTd1DFXhdkrvg1szxfHhawXUZ3g9TkXORQd4/WG68jMlQZ2p8wlg== + dependencies: + type-fest "^0.7.1" + +static-extend@^0.1.1: + version "0.1.2" + resolved "https://registry.npmjs.org/static-extend/-/static-extend-0.1.2.tgz" + integrity sha1-YICcOcv/VTNyJv1eC1IPNB8ftcY= + dependencies: + define-property "^0.2.5" + object-copy "^0.1.0" + +statuses@2.0.1: + version "2.0.1" + resolved "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz" + integrity sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ== + +stealthy-require@^1.1.1: + version "1.1.1" + resolved "https://registry.npmjs.org/stealthy-require/-/stealthy-require-1.1.1.tgz" + integrity sha1-NbCYdbT/SfJqd35QmzCQoyJr8ks= + +stream-to-pull-stream@^1.7.1: + version "1.7.3" + resolved "https://registry.npmjs.org/stream-to-pull-stream/-/stream-to-pull-stream-1.7.3.tgz" + integrity sha512-6sNyqJpr5dIOQdgNy/xcDWwDuzAsAwVzhzrWlAPAQ7Lkjx/rv0wgvxEyKwTq6FmNd5rjTrELt/CLmaSw7crMGg== + dependencies: + looper "^3.0.0" + pull-stream "^3.2.3" + +strict-uri-encode@^1.0.0: + version "1.1.0" + resolved "https://registry.npmjs.org/strict-uri-encode/-/strict-uri-encode-1.1.0.tgz" + integrity sha1-J5siXfHVgrH1TmWt3UNS4Y+qBxM= + +string-argv@^0.3.1: + version "0.3.1" + resolved "https://registry.npmjs.org/string-argv/-/string-argv-0.3.1.tgz" + integrity sha512-a1uQGz7IyVy9YwhqjZIZu1c8JO8dNIe20xBmSS6qu9kv++k3JGzCVmprbNN5Kn+BgzD5E7YYwg1CcjuJMRNsvg== + +string-format@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/string-format/-/string-format-2.0.0.tgz" + integrity sha512-bbEs3scLeYNXLecRRuk6uJxdXUSj6le/8rNPHChIJTn2V79aXVTR1EH2OH5zLKKoz0V02fOUKZZcw01pLUShZA== + +string-width@^1.0.1: + version "1.0.2" + resolved "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz" + integrity sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M= + dependencies: + code-point-at "^1.0.0" + is-fullwidth-code-point "^1.0.0" + strip-ansi "^3.0.0" + +"string-width@^1.0.2 || 2", string-width@^2.1.0, string-width@^2.1.1: + version "2.1.1" + resolved "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz" + integrity sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw== + dependencies: + is-fullwidth-code-point "^2.0.0" + strip-ansi "^4.0.0" + +string-width@^3.0.0, string-width@^3.1.0: + version "3.1.0" + resolved "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz" + integrity sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w== + dependencies: + emoji-regex "^7.0.1" + is-fullwidth-code-point "^2.0.0" + strip-ansi "^5.1.0" + +string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.3: + version "4.2.3" + resolved "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz" + integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g== + dependencies: + emoji-regex "^8.0.0" + is-fullwidth-code-point "^3.0.0" + strip-ansi "^6.0.1" + +string-width@^5.0.0: + version "5.1.2" + resolved "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz" + integrity sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA== + dependencies: + eastasianwidth "^0.2.0" + emoji-regex "^9.2.2" + strip-ansi "^7.0.1" + +string.prototype.trim@~1.2.5: + version "1.2.6" + resolved "https://registry.yarnpkg.com/string.prototype.trim/-/string.prototype.trim-1.2.6.tgz#824960787db37a9e24711802ed0c1d1c0254f83e" + integrity sha512-8lMR2m+U0VJTPp6JjvJTtGyc4FIGq9CdRt7O9p6T0e6K4vjU+OP+SQJpbe/SBmRcCUIvNUnjsbmY6lnMp8MhsQ== + dependencies: + call-bind "^1.0.2" + define-properties "^1.1.4" + es-abstract "^1.19.5" + +string.prototype.trimend@^1.0.4: + version "1.0.4" + resolved "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.4.tgz" + integrity sha512-y9xCjw1P23Awk8EvTpcyL2NIr1j7wJ39f+k6lvRnSMz+mz9CGz9NYPelDk42kOz6+ql8xjfK8oYzy3jAP5QU5A== + dependencies: + call-bind "^1.0.2" + define-properties "^1.1.3" + +string.prototype.trimend@^1.0.5: + version "1.0.5" + resolved "https://registry.yarnpkg.com/string.prototype.trimend/-/string.prototype.trimend-1.0.5.tgz#914a65baaab25fbdd4ee291ca7dde57e869cb8d0" + integrity sha512-I7RGvmjV4pJ7O3kdf+LXFpVfdNOxtCW/2C8f6jNiW4+PQchwxkCDzlk1/7p+Wl4bqFIZeF47qAHXLuHHWKAxog== + dependencies: + call-bind "^1.0.2" + define-properties "^1.1.4" + es-abstract "^1.19.5" + +string.prototype.trimstart@^1.0.4: + version "1.0.4" + resolved "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.4.tgz" + integrity sha512-jh6e984OBfvxS50tdY2nRZnoC5/mLFKOREQfw8t5yytkoUsJRNxvI/E39qu1sD0OtWI3OC0XgKSmcWwziwYuZw== + dependencies: + call-bind "^1.0.2" + define-properties "^1.1.3" + +string.prototype.trimstart@^1.0.5: + version "1.0.5" + resolved "https://registry.yarnpkg.com/string.prototype.trimstart/-/string.prototype.trimstart-1.0.5.tgz#5466d93ba58cfa2134839f81d7f42437e8c01fef" + integrity sha512-THx16TJCGlsN0o6dl2o6ncWUsdgnLRSA23rRE5pyGBw/mLr3Ej/R2LaqCtgP8VNMGZsvMWnf9ooZPyY2bHvUFg== + dependencies: + call-bind "^1.0.2" + define-properties "^1.1.4" + es-abstract "^1.19.5" + +string_decoder@^1.1.1: + version "1.3.0" + resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz" + integrity sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA== + dependencies: + safe-buffer "~5.2.0" + +string_decoder@~0.10.x: + version "0.10.31" + resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz" + integrity sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ= + +string_decoder@~1.1.1: + version "1.1.1" + resolved "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz" + integrity sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg== + dependencies: + safe-buffer "~5.1.0" + +strip-ansi@^3.0.0, strip-ansi@^3.0.1: + version "3.0.1" + resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz" + integrity sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8= + dependencies: + ansi-regex "^2.0.0" + +strip-ansi@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz" + integrity sha1-qEeQIusaw2iocTibY1JixQXuNo8= + dependencies: + ansi-regex "^3.0.0" + +strip-ansi@^5.0.0, strip-ansi@^5.1.0, strip-ansi@^5.2.0: + version "5.2.0" + resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz" + integrity sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA== + dependencies: + ansi-regex "^4.1.0" + +strip-ansi@^6.0.0, strip-ansi@^6.0.1: + version "6.0.1" + resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz" + integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A== + dependencies: + ansi-regex "^5.0.1" + +strip-ansi@^7.0.1: + version "7.0.1" + resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.0.1.tgz" + integrity sha512-cXNxvT8dFNRVfhVME3JAe98mkXDYN2O1l7jmcwMnOslDeESg1rF/OZMtK0nRAhiari1unG5cD4jG3rapUAkLbw== + dependencies: + ansi-regex "^6.0.1" + +strip-bom@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/strip-bom/-/strip-bom-2.0.0.tgz" + integrity sha1-YhmoVhZSBJHzV4i9vxRHqZx+aw4= + dependencies: + is-utf8 "^0.2.0" + +strip-bom@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz" + integrity sha1-IzTBjpx1n3vdVv3vfprj1YjmjtM= + +strip-final-newline@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-2.0.0.tgz" + integrity sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA== + +strip-hex-prefix@1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/strip-hex-prefix/-/strip-hex-prefix-1.0.0.tgz" + integrity sha1-DF8VX+8RUTczd96du1iNoFUA428= + dependencies: + is-hex-prefixed "1.0.0" + +strip-json-comments@2.0.1, strip-json-comments@^2.0.1: + version "2.0.1" + resolved "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz" + integrity sha1-PFMZQukIwml8DsNEhYwobHygpgo= + +strip-json-comments@3.1.1, strip-json-comments@^3.1.0, strip-json-comments@^3.1.1: + version "3.1.1" + resolved "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz" + integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig== + +supports-color@6.0.0: + version "6.0.0" + resolved "https://registry.npmjs.org/supports-color/-/supports-color-6.0.0.tgz" + integrity sha512-on9Kwidc1IUQo+bQdhi8+Tijpo0e1SS6RoGo2guUwn5vdaxw8RXOF9Vb2ws+ihWOmh4JnCJOvaziZWP1VABaLg== + dependencies: + has-flag "^3.0.0" + +supports-color@8.1.1: + version "8.1.1" + resolved "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz" + integrity sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q== + dependencies: + has-flag "^4.0.0" + +supports-color@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/supports-color/-/supports-color-2.0.0.tgz" + integrity sha1-U10EXOa2Nj+kARcIRimZXp3zJMc= + +supports-color@^3.1.0: + version "3.2.3" + resolved "https://registry.npmjs.org/supports-color/-/supports-color-3.2.3.tgz" + integrity sha1-ZawFBLOVQXHYpklGsq48u4pfVPY= + dependencies: + has-flag "^1.0.0" + +supports-color@^5.3.0: + version "5.5.0" + resolved "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz" + integrity sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow== + dependencies: + has-flag "^3.0.0" + +supports-color@^7.1.0: + version "7.2.0" + resolved "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz" + integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw== + dependencies: + has-flag "^4.0.0" + +supports-color@^9.2.1: + version "9.2.2" + resolved "https://registry.npmjs.org/supports-color/-/supports-color-9.2.2.tgz" + integrity sha512-XC6g/Kgux+rJXmwokjm9ECpD6k/smUoS5LKlUCcsYr4IY3rW0XyAympon2RmxGrlnZURMpg5T18gWDP9CsHXFA== + +supports-preserve-symlinks-flag@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz" + integrity sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w== + +swarm-js@^0.1.40: + version "0.1.40" + resolved "https://registry.npmjs.org/swarm-js/-/swarm-js-0.1.40.tgz" + integrity sha512-yqiOCEoA4/IShXkY3WKwP5PvZhmoOOD8clsKA7EEcRILMkTEYHCQ21HDCAcVpmIxZq4LyZvWeRJ6quIyHk1caA== + dependencies: + bluebird "^3.5.0" + buffer "^5.0.5" + eth-lib "^0.1.26" + fs-extra "^4.0.2" + got "^7.1.0" + mime-types "^2.1.16" + mkdirp-promise "^5.0.1" + mock-fs "^4.1.0" + setimmediate "^1.0.5" + tar "^4.0.2" + xhr-request "^1.0.1" + +sync-request@^6.0.0: + version "6.1.0" + resolved "https://registry.npmjs.org/sync-request/-/sync-request-6.1.0.tgz" + integrity sha512-8fjNkrNlNCrVc/av+Jn+xxqfCjYaBoHqCsDz6mt030UMxJGr+GSfCV1dQt2gRtlL63+VPidwDVLr7V2OcTSdRw== + dependencies: + http-response-object "^3.0.1" + sync-rpc "^1.2.1" + then-request "^6.0.0" + +sync-rpc@^1.2.1: + version "1.3.6" + resolved "https://registry.npmjs.org/sync-rpc/-/sync-rpc-1.3.6.tgz" + integrity sha512-J8jTXuZzRlvU7HemDgHi3pGnh/rkoqR/OZSjhTyyZrEkkYQbk7Z33AXp37mkPfPpfdOuj7Ex3H/TJM1z48uPQw== + dependencies: + get-port "^3.1.0" + +table-layout@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/table-layout/-/table-layout-1.0.2.tgz" + integrity sha512-qd/R7n5rQTRFi+Zf2sk5XVVd9UQl6ZkduPFC3S7WEGJAmetDTjY3qPN50eSKzwuzEyQKy5TN2TiZdkIjos2L6A== + dependencies: + array-back "^4.0.1" + deep-extend "~0.6.0" + typical "^5.2.0" + wordwrapjs "^4.0.0" + +table@^5.2.3: + version "5.4.6" + resolved "https://registry.npmjs.org/table/-/table-5.4.6.tgz" + integrity sha512-wmEc8m4fjnob4gt5riFRtTu/6+4rSe12TpAELNSqHMfF3IqnA+CH37USM6/YR3qRZv7e56kAEAtd6nKZaxe0Ug== + dependencies: + ajv "^6.10.2" + lodash "^4.17.14" + slice-ansi "^2.1.0" + string-width "^3.0.0" + +table@^6.8.0: + version "6.8.0" + resolved "https://registry.yarnpkg.com/table/-/table-6.8.0.tgz#87e28f14fa4321c3377ba286f07b79b281a3b3ca" + integrity sha512-s/fitrbVeEyHKFa7mFdkuQMWlH1Wgw/yEXMt5xACT4ZpzWFluehAxRtUUQKPuWhaLAWhFcVx6w3oC8VKaUfPGA== + dependencies: + ajv "^8.0.1" + lodash.truncate "^4.4.2" + slice-ansi "^4.0.0" + string-width "^4.2.3" + strip-ansi "^6.0.1" + +tape@^4.6.3: + version "4.15.1" + resolved "https://registry.yarnpkg.com/tape/-/tape-4.15.1.tgz#88fb662965a11f9be1bddb04c11662d7eceb129e" + integrity sha512-k7F5pyr91n9D/yjSJwbLLYDCrTWXxMSXbbmHX2n334lSIc2rxeXyFkaBv4UuUd2gBYMrAOalPutAiCxC6q1qbw== + dependencies: + call-bind "~1.0.2" + deep-equal "~1.1.1" + defined "~1.0.0" + dotignore "~0.1.2" + for-each "~0.3.3" + glob "~7.2.0" + has "~1.0.3" + inherits "~2.0.4" + is-regex "~1.1.4" + minimist "~1.2.6" + object-inspect "~1.12.0" + resolve "~1.22.0" + resumer "~0.0.0" + string.prototype.trim "~1.2.5" + through "~2.3.8" + +tar@^4.0.2: + version "4.4.19" + resolved "https://registry.npmjs.org/tar/-/tar-4.4.19.tgz" + integrity sha512-a20gEsvHnWe0ygBY8JbxoM4w3SJdhc7ZAuxkLqh+nvNQN2IOt0B5lLgM490X5Hl8FF0dl0tOf2ewFYAlIFgzVA== + dependencies: + chownr "^1.1.4" + fs-minipass "^1.2.7" + minipass "^2.9.0" + minizlib "^1.3.3" + mkdirp "^0.5.5" + safe-buffer "^5.2.1" + yallist "^3.1.1" + +test-value@^2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/test-value/-/test-value-2.1.0.tgz" + integrity sha1-Edpv9nDzRxpztiXKTz/c97t0gpE= + dependencies: + array-back "^1.0.3" + typical "^2.6.0" + +testrpc@0.0.1: + version "0.0.1" + resolved "https://registry.npmjs.org/testrpc/-/testrpc-0.0.1.tgz" + integrity sha512-afH1hO+SQ/VPlmaLUFj2636QMeDvPCeQMc/9RBMW0IfjNe9gFD9Ra3ShqYkB7py0do1ZcCna/9acHyzTJ+GcNA== + +text-table@^0.2.0: + version "0.2.0" + resolved "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz" + integrity sha1-f17oI66AUgfACvLfSoTsP8+lcLQ= + +then-request@^6.0.0: + version "6.0.2" + resolved "https://registry.npmjs.org/then-request/-/then-request-6.0.2.tgz" + integrity sha512-3ZBiG7JvP3wbDzA9iNY5zJQcHL4jn/0BWtXIkagfz7QgOL/LqjCEOBQuJNZfu0XYnv5JhKh+cDxCPM4ILrqruA== + dependencies: + "@types/concat-stream" "^1.6.0" + "@types/form-data" "0.0.33" + "@types/node" "^8.0.0" + "@types/qs" "^6.2.31" + caseless "~0.12.0" + concat-stream "^1.6.0" + form-data "^2.2.0" + http-basic "^8.1.1" + http-response-object "^3.0.1" + promise "^8.0.0" + qs "^6.4.0" + +through2@^2.0.3: + version "2.0.5" + resolved "https://registry.npmjs.org/through2/-/through2-2.0.5.tgz" + integrity sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ== + dependencies: + readable-stream "~2.3.6" + xtend "~4.0.1" + +through@^2.3.6, through@^2.3.8, through@~2.3.4, through@~2.3.8: + version "2.3.8" + resolved "https://registry.npmjs.org/through/-/through-2.3.8.tgz" + integrity sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU= + +timed-out@^4.0.0, timed-out@^4.0.1: + version "4.0.1" + resolved "https://registry.npmjs.org/timed-out/-/timed-out-4.0.1.tgz" + integrity sha1-8y6srFoXW+ol1/q1Zas+2HQe9W8= + +tiny-invariant@^1.1.0: + version "1.2.0" + resolved "https://registry.yarnpkg.com/tiny-invariant/-/tiny-invariant-1.2.0.tgz#a1141f86b672a9148c72e978a19a73b9b94a15a9" + integrity sha512-1Uhn/aqw5C6RI4KejVeTg6mIS7IqxnLJ8Mv2tV5rTc0qWobay7pDUz6Wi392Cnc8ak1H0F2cjoRzb2/AW4+Fvg== + +tiny-warning@^1.0.0: + version "1.0.3" + resolved "https://registry.yarnpkg.com/tiny-warning/-/tiny-warning-1.0.3.tgz#94a30db453df4c643d0fd566060d60a875d84754" + integrity sha512-lBN9zLN/oAf68o3zNXYrdCt1kP8WsiGW8Oo2ka41b2IM5JL/S1CTyX1rW0mb/zSuJun0ZUrDxx4sqvYS2FWzPA== + +tmp@0.0.33, tmp@^0.0.33: + version "0.0.33" + resolved "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz" + integrity sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw== + dependencies: + os-tmpdir "~1.0.2" + +tmp@0.1.0: + version "0.1.0" + resolved "https://registry.npmjs.org/tmp/-/tmp-0.1.0.tgz" + integrity sha512-J7Z2K08jbGcdA1kkQpJSqLF6T0tdQqpR2pnSUXsIchbPdTI9v3e85cLW0d6WDhwuAleOV71j2xWs8qMPfK7nKw== + dependencies: + rimraf "^2.6.3" + +to-fast-properties@^1.0.3: + version "1.0.3" + resolved "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-1.0.3.tgz" + integrity sha1-uDVx+k2MJbguIxsG46MFXeTKGkc= + +to-object-path@^0.3.0: + version "0.3.0" + resolved "https://registry.npmjs.org/to-object-path/-/to-object-path-0.3.0.tgz" + integrity sha1-KXWIt7Dn4KwI4E5nL4XB9JmeF68= + dependencies: + kind-of "^3.0.2" + +to-readable-stream@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/to-readable-stream/-/to-readable-stream-1.0.0.tgz" + integrity sha512-Iq25XBt6zD5npPhlLVXGFN3/gyR2/qODcKNNyTMd4vbm39HUaOiAM4PMq0eMVC/Tkxz+Zjdsc55g9yyz+Yq00Q== + +to-regex-range@^2.1.0: + version "2.1.1" + resolved "https://registry.npmjs.org/to-regex-range/-/to-regex-range-2.1.1.tgz" + integrity sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg= + dependencies: + is-number "^3.0.0" + repeat-string "^1.6.1" + +to-regex-range@^5.0.1: + version "5.0.1" + resolved "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz" + integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ== + dependencies: + is-number "^7.0.0" + +to-regex@^3.0.1, to-regex@^3.0.2: + version "3.0.2" + resolved "https://registry.npmjs.org/to-regex/-/to-regex-3.0.2.tgz" + integrity sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw== + dependencies: + define-property "^2.0.2" + extend-shallow "^3.0.2" + regex-not "^1.0.2" + safe-regex "^1.1.0" + +toformat@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/toformat/-/toformat-2.0.0.tgz#7a043fd2dfbe9021a4e36e508835ba32056739d8" + integrity sha512-03SWBVop6nU8bpyZCx7SodpYznbZF5R4ljwNLBcTQzKOD9xuihRo/psX58llS1BMFhhAI08H3luot5GoXJz2pQ== + +toidentifier@1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz" + integrity sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA== + +tough-cookie@^2.3.3, tough-cookie@~2.5.0: + version "2.5.0" + resolved "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.5.0.tgz" + integrity sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g== + dependencies: + psl "^1.1.28" + punycode "^2.1.1" + +trim-right@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/trim-right/-/trim-right-1.0.1.tgz" + integrity sha1-yy4SAwZ+DI3h9hQJS5/kVwTqYAM= + +"true-case-path@^2.2.1": + version "2.2.1" + resolved "https://registry.npmjs.org/true-case-path/-/true-case-path-2.2.1.tgz" + integrity sha512-0z3j8R7MCjy10kc/g+qg7Ln3alJTodw9aDuVWZa3uiWqfuBMKeAeP2ocWcxoyM3D73yz3Jt/Pu4qPr4wHSdB/Q== + +ts-command-line-args@^2.2.0: + version "2.2.1" + resolved "https://registry.npmjs.org/ts-command-line-args/-/ts-command-line-args-2.2.1.tgz" + integrity sha512-mnK68QA86FYzQYTSA/rxIjT/8EpKsvQw9QkawPic8I8t0gjAOw3Oa509NIRoaY1FmH7hdrncMp7t7o+vYoceNQ== + dependencies: + chalk "^4.1.0" + command-line-args "^5.1.1" + command-line-usage "^6.1.0" + string-format "^2.0.0" + +ts-essentials@^1.0.0: + version "1.0.4" + resolved "https://registry.npmjs.org/ts-essentials/-/ts-essentials-1.0.4.tgz" + integrity sha512-q3N1xS4vZpRouhYHDPwO0bDW3EZ6SK9CrrDHxi/D6BPReSjpVgWIOpLS2o0gSBZm+7q/wyKp6RVM1AeeW7uyfQ== + +ts-essentials@^6.0.3: + version "6.0.7" + resolved "https://registry.npmjs.org/ts-essentials/-/ts-essentials-6.0.7.tgz" + integrity sha512-2E4HIIj4tQJlIHuATRHayv0EfMGK3ris/GRk1E3CFnsZzeNV+hUmelbaTZHLtXaZppM5oLhHRtO04gINC4Jusw== + +ts-essentials@^7.0.1: + version "7.0.3" + resolved "https://registry.npmjs.org/ts-essentials/-/ts-essentials-7.0.3.tgz" + integrity sha512-8+gr5+lqO3G84KdiTSMRLtuyJ+nTBVRKuCrK4lidMPdVeEp0uqC875uE5NMcaA7YYMN7XsNiFQuMvasF8HT/xQ== + +ts-generator@^0.1.1: + version "0.1.1" + resolved "https://registry.npmjs.org/ts-generator/-/ts-generator-0.1.1.tgz" + integrity sha512-N+ahhZxTLYu1HNTQetwWcx3so8hcYbkKBHTr4b4/YgObFTIKkOSSsaa+nal12w8mfrJAyzJfETXawbNjSfP2gQ== + dependencies: + "@types/mkdirp" "^0.5.2" + "@types/prettier" "^2.1.1" + "@types/resolve" "^0.0.8" + chalk "^2.4.1" + glob "^7.1.2" + mkdirp "^0.5.1" + prettier "^2.1.2" + resolve "^1.8.1" + ts-essentials "^1.0.0" + +ts-node@^10.4.0: + version "10.7.0" + resolved "https://registry.npmjs.org/ts-node/-/ts-node-10.7.0.tgz" + integrity sha512-TbIGS4xgJoX2i3do417KSaep1uRAW/Lu+WAL2doDHC0D6ummjirVOXU5/7aiZotbQ5p1Zp9tP7U6cYhA0O7M8A== + dependencies: + "@cspotcode/source-map-support" "0.7.0" + "@tsconfig/node10" "^1.0.7" + "@tsconfig/node12" "^1.0.7" + "@tsconfig/node14" "^1.0.0" + "@tsconfig/node16" "^1.0.2" + acorn "^8.4.1" + acorn-walk "^8.1.1" + arg "^4.1.0" + create-require "^1.1.0" + diff "^4.0.1" + make-error "^1.1.1" + v8-compile-cache-lib "^3.0.0" + yn "3.1.1" + +tsconfig-paths@^3.14.1: + version "3.14.1" + resolved "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-3.14.1.tgz" + integrity sha512-fxDhWnFSLt3VuTwtvJt5fpwxBHg5AdKWMsgcPOOIilyjymcYVZoCQF8fvFRezCNfblEXmi+PcM1eYHeOAgXCOQ== + dependencies: + "@types/json5" "^0.0.29" + json5 "^1.0.1" + minimist "^1.2.6" + strip-bom "^3.0.0" + +tslib@^1.8.1, tslib@^1.9.0, tslib@^1.9.3: + version "1.14.1" + resolved "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz" + integrity sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg== + +tslib@^2.1.0: + version "2.4.0" + resolved "https://registry.npmjs.org/tslib/-/tslib-2.4.0.tgz" + integrity sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ== + +tsort@0.0.1: + version "0.0.1" + resolved "https://registry.npmjs.org/tsort/-/tsort-0.0.1.tgz" + integrity sha1-4igPXoF/i/QnVlf9D5rr1E9aJ4Y= + +tsutils@^3.21.0: + version "3.21.0" + resolved "https://registry.npmjs.org/tsutils/-/tsutils-3.21.0.tgz" + integrity sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA== + dependencies: + tslib "^1.8.1" + +tunnel-agent@^0.6.0: + version "0.6.0" + resolved "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz" + integrity sha1-J6XeoGs2sEoKmWZ3SykIaPD8QP0= + dependencies: + safe-buffer "^5.0.1" + +tweetnacl-util@^0.15.0, tweetnacl-util@^0.15.1: + version "0.15.1" + resolved "https://registry.npmjs.org/tweetnacl-util/-/tweetnacl-util-0.15.1.tgz" + integrity sha512-RKJBIj8lySrShN4w6i/BonWp2Z/uxwC3h4y7xsRrpP59ZboCd0GpEVsOnMDYLMmKBpYhb5TgHzZXy7wTfYFBRw== + +tweetnacl@^0.14.3, tweetnacl@~0.14.0: + version "0.14.5" + resolved "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.14.5.tgz" + integrity sha1-WuaBd/GS1EViadEIr6k/+HQ/T2Q= + +tweetnacl@^1.0.0, tweetnacl@^1.0.3: + version "1.0.3" + resolved "https://registry.npmjs.org/tweetnacl/-/tweetnacl-1.0.3.tgz" + integrity sha512-6rt+RN7aOi1nGMyC4Xa5DdYiukl2UWCbcJft7YhxReBGQD7OAM8Pbxw6YMo4r2diNEA8FEmu32YOn9rhaiE5yw== + +type-check@^0.4.0, type-check@~0.4.0: + version "0.4.0" + resolved "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz" + integrity sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew== + dependencies: + prelude-ls "^1.2.1" + +type-check@~0.3.2: + version "0.3.2" + resolved "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz" + integrity sha1-WITKtRLPHTVeP7eE8wgEsrUg23I= + dependencies: + prelude-ls "~1.1.2" + +type-detect@^4.0.0, type-detect@^4.0.5: + version "4.0.8" + resolved "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz" + integrity sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g== + +type-fest@^0.20.2: + version "0.20.2" + resolved "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz" + integrity sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ== + +type-fest@^0.21.3: + version "0.21.3" + resolved "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz" + integrity sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w== + +type-fest@^0.7.1: + version "0.7.1" + resolved "https://registry.npmjs.org/type-fest/-/type-fest-0.7.1.tgz" + integrity sha512-Ne2YiiGN8bmrmJJEuTWTLJR32nh/JdL1+PSicowtNb0WFpn59GK8/lfD61bVtzguz7b3PBt74nxpv/Pw5po5Rg== + +type-is@~1.6.18: + version "1.6.18" + resolved "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz" + integrity sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g== + dependencies: + media-typer "0.3.0" + mime-types "~2.1.24" + +type@^1.0.1: + version "1.2.0" + resolved "https://registry.npmjs.org/type/-/type-1.2.0.tgz" + integrity sha512-+5nt5AAniqsCnu2cEQQdpzCAh33kVx8n0VoFidKpB1dVVLAN/F+bgVOqOJqOnEnrhp222clB5p3vUlD+1QAnfg== + +type@^2.5.0: + version "2.6.0" + resolved "https://registry.npmjs.org/type/-/type-2.6.0.tgz" + integrity sha512-eiDBDOmkih5pMbo9OqsqPRGMljLodLcwd5XD5JbtNB0o89xZAwynY9EdCDsJU7LtcVCClu9DvM7/0Ep1hYX3EQ== + +typechain@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/typechain/-/typechain-3.0.0.tgz" + integrity sha512-ft4KVmiN3zH4JUFu2WJBrwfHeDf772Tt2d8bssDTo/YcckKW2D+OwFrHXRC6hJvO3mHjFQTihoMV6fJOi0Hngg== + dependencies: + command-line-args "^4.0.7" + debug "^4.1.1" + fs-extra "^7.0.0" + js-sha3 "^0.8.0" + lodash "^4.17.15" + ts-essentials "^6.0.3" + ts-generator "^0.1.1" + +typechain@^8.0.0: + version "8.0.0" + resolved "https://registry.npmjs.org/typechain/-/typechain-8.0.0.tgz" + integrity sha512-rqDfDYc9voVAhmfVfAwzg3VYFvhvs5ck1X9T/iWkX745Cul4t+V/smjnyqrbDzWDbzD93xfld1epg7Y/uFAesQ== + dependencies: + "@types/prettier" "^2.1.1" + debug "^4.3.1" + fs-extra "^7.0.0" + glob "7.1.7" + js-sha3 "^0.8.0" + lodash "^4.17.15" + mkdirp "^1.0.4" + prettier "^2.3.1" + ts-command-line-args "^2.2.0" + ts-essentials "^7.0.1" + +typedarray-to-buffer@^3.1.5: + version "3.1.5" + resolved "https://registry.npmjs.org/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz" + integrity sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q== + dependencies: + is-typedarray "^1.0.0" + +typedarray@^0.0.6: + version "0.0.6" + resolved "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz" + integrity sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c= + +typescript@^4.5.4: + version "4.6.4" + resolved "https://registry.npmjs.org/typescript/-/typescript-4.6.4.tgz" + integrity sha512-9ia/jWHIEbo49HfjrLGfKbZSuWo9iTMwXO+Ca3pRsSpbsMbc7/IU8NKdCZVRRBafVPGnoJeFL76ZOAA84I9fEg== + +typewise-core@^1.2, typewise-core@^1.2.0: + version "1.2.0" + resolved "https://registry.npmjs.org/typewise-core/-/typewise-core-1.2.0.tgz" + integrity sha1-l+uRgFx/VdL5QXSPpQ0xXZke8ZU= + +typewise@^1.0.3: + version "1.0.3" + resolved "https://registry.npmjs.org/typewise/-/typewise-1.0.3.tgz" + integrity sha1-EGeTZUCvl5N8xdz5kiSG6fooRlE= + dependencies: + typewise-core "^1.2.0" + +typewiselite@~1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/typewiselite/-/typewiselite-1.0.0.tgz" + integrity sha1-yIgvobsQksBgBal/NO9chQjjZk4= + +typical@^2.6.0, typical@^2.6.1: + version "2.6.1" + resolved "https://registry.npmjs.org/typical/-/typical-2.6.1.tgz" + integrity sha1-XAgOXWYcu+OCWdLnCjxyU+hziB0= + +typical@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/typical/-/typical-4.0.0.tgz" + integrity sha512-VAH4IvQ7BDFYglMd7BPRDfLgxZZX4O4TFcRDA6EN5X7erNJJq+McIEp8np9aVtxrCJ6qx4GTYVfOWNjcqwZgRw== + +typical@^5.2.0: + version "5.2.0" + resolved "https://registry.npmjs.org/typical/-/typical-5.2.0.tgz" + integrity sha512-dvdQgNDNJo+8B2uBQoqdb11eUCE1JQXhvjC/CZtgvZseVd5TYMXnq0+vuUemXbd/Se29cTaUuPX3YIc2xgbvIg== + +uglify-js@^3.1.4: + version "3.15.4" + resolved "https://registry.npmjs.org/uglify-js/-/uglify-js-3.15.4.tgz" + integrity sha512-vMOPGDuvXecPs34V74qDKk4iJ/SN4vL3Ow/23ixafENYvtrNvtbcgUeugTcUGRGsOF/5fU8/NYSL5Hyb3l1OJA== + +ultron@~1.1.0: + version "1.1.1" + resolved "https://registry.npmjs.org/ultron/-/ultron-1.1.1.tgz" + integrity sha512-UIEXBNeYmKptWH6z8ZnqTeS8fV74zG0/eRU9VGkpzz+LIJNs8W/zM/L+7ctCkRrgbNnnR0xxw4bKOr0cW0N0Og== + +unbox-primitive@^1.0.1, unbox-primitive@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.0.2.tgz" + integrity sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw== + dependencies: + call-bind "^1.0.2" + has-bigints "^1.0.2" + has-symbols "^1.0.3" + which-boxed-primitive "^1.0.2" + +underscore@1.9.1, underscore@>=1.12.1: + version "1.13.3" + resolved "https://registry.yarnpkg.com/underscore/-/underscore-1.13.3.tgz#54bc95f7648c5557897e5e968d0f76bc062c34ee" + integrity sha512-QvjkYpiD+dJJraRA8+dGAU4i7aBbb2s0S3jA45TFOvg2VgqvdCDd/3N6CqA8gluk1W91GLoXg5enMUx560QzuA== + +undici@^4.14.1: + version "4.16.0" + resolved "https://registry.npmjs.org/undici/-/undici-4.16.0.tgz" + integrity sha512-tkZSECUYi+/T1i4u+4+lwZmQgLXd4BLGlrc7KZPcLIW7Jpq99+Xpc30ONv7nS6F5UNOxp/HBZSSL9MafUrvJbw== + +undici@^5.4.0: + version "5.5.1" + resolved "https://registry.yarnpkg.com/undici/-/undici-5.5.1.tgz#baaf25844a99eaa0b22e1ef8d205bffe587c8f43" + integrity sha512-MEvryPLf18HvlCbLSzCW0U00IMftKGI5udnjrQbC5D4P0Hodwffhv+iGfWuJwg16Y/TK11ZFK8i+BPVW2z/eAw== + +union-value@^1.0.0: + version "1.0.1" + resolved "https://registry.npmjs.org/union-value/-/union-value-1.0.1.tgz" + integrity sha512-tJfXmxMeWYnczCVs7XAEvIV7ieppALdyepWMkHkwciRpZraG/xwT+s2JN8+pr1+8jCRf80FFzvr+MpQeeoF4Xg== + dependencies: + arr-union "^3.1.0" + get-value "^2.0.6" + is-extendable "^0.1.1" + set-value "^2.0.1" + +universalify@^0.1.0: + version "0.1.2" + resolved "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz" + integrity sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg== + +universalify@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/universalify/-/universalify-2.0.0.tgz" + integrity sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ== + +unorm@^1.3.3: + version "1.6.0" + resolved "https://registry.npmjs.org/unorm/-/unorm-1.6.0.tgz" + integrity sha512-b2/KCUlYZUeA7JFUuRJZPUtr4gZvBh7tavtv4fvk4+KV9pfGiR6CQAQAWl49ZpR3ts2dk4FYkP7EIgDJoiOLDA== + +unpipe@1.0.0, unpipe@~1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz" + integrity sha1-sr9O6FFKrmFltIF4KdIbLvSZBOw= + +unset-value@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/unset-value/-/unset-value-1.0.0.tgz" + integrity sha1-g3aHP30jNRef+x5vw6jtDfyKtVk= + dependencies: + has-value "^0.3.1" + isobject "^3.0.0" + +uri-js@^4.2.2: + version "4.4.1" + resolved "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz" + integrity sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg== + dependencies: + punycode "^2.1.0" + +urix@^0.1.0: + version "0.1.0" + resolved "https://registry.npmjs.org/urix/-/urix-0.1.0.tgz" + integrity sha1-2pN/emLiH+wf0Y1Js1wpNQZ6bHI= + +url-parse-lax@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/url-parse-lax/-/url-parse-lax-1.0.0.tgz" + integrity sha1-evjzA2Rem9eaJy56FKxovAYJ2nM= + dependencies: + prepend-http "^1.0.1" + +url-parse-lax@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/url-parse-lax/-/url-parse-lax-3.0.0.tgz" + integrity sha1-FrXK/Afb42dsGxmZF3gj1lA6yww= + dependencies: + prepend-http "^2.0.0" + +url-set-query@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/url-set-query/-/url-set-query-1.0.0.tgz" + integrity sha1-AW6M/Xwg7gXK/neV6JK9BwL6ozk= + +url-to-options@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/url-to-options/-/url-to-options-1.0.1.tgz" + integrity sha1-FQWgOiiaSMvXpDTvuu7FBV9WM6k= + +url@^0.11.0: + version "0.11.0" + resolved "https://registry.npmjs.org/url/-/url-0.11.0.tgz" + integrity sha1-ODjpfPxgUh63PFJajlW/3Z4uKPE= + dependencies: + punycode "1.3.2" + querystring "0.2.0" + +use@^3.1.0: + version "3.1.1" + resolved "https://registry.npmjs.org/use/-/use-3.1.1.tgz" + integrity sha512-cwESVXlO3url9YWlFW/TA9cshCEhtu7IKJ/p5soJ/gGpj7vbvFrAY/eIioQ6Dw23KjZhYgiIo8HOs1nQ2vr/oQ== + +utf-8-validate@^5.0.2: + version "5.0.9" + resolved "https://registry.npmjs.org/utf-8-validate/-/utf-8-validate-5.0.9.tgz" + integrity sha512-Yek7dAy0v3Kl0orwMlvi7TPtiCNrdfHNd7Gcc/pLq4BLXqfAmd0J7OWMizUQnTTJsyjKn02mU7anqwfmUP4J8Q== + dependencies: + node-gyp-build "^4.3.0" + +utf8@3.0.0, utf8@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/utf8/-/utf8-3.0.0.tgz" + integrity sha512-E8VjFIQ/TyQgp+TZfS6l8yp/xWppSAHzidGiRrqe4bK4XP9pTRyKFgGJpO3SN7zdX4DeomTrwaseCHovfpFcqQ== + +util-deprecate@^1.0.1, util-deprecate@~1.0.1: + version "1.0.2" + resolved "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz" + integrity sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8= + +util.promisify@^1.0.0: + version "1.1.1" + resolved "https://registry.npmjs.org/util.promisify/-/util.promisify-1.1.1.tgz" + integrity sha512-/s3UsZUrIfa6xDhr7zZhnE9SLQ5RIXyYfiVnMMyMDzOc8WhWN4Nbh36H842OyurKbCDAesZOJaVyvmSl6fhGQw== + dependencies: + call-bind "^1.0.0" + define-properties "^1.1.3" + for-each "^0.3.3" + has-symbols "^1.0.1" + object.getownpropertydescriptors "^2.1.1" + +util@^0.12.0: + version "0.12.4" + resolved "https://registry.npmjs.org/util/-/util-0.12.4.tgz" + integrity sha512-bxZ9qtSlGUWSOy9Qa9Xgk11kSslpuZwaxCg4sNIDj6FLucDab2JxnHwyNTCpHMtK1MjoQiWQ6DiUMZYbSrO+Sw== + dependencies: + inherits "^2.0.3" + is-arguments "^1.0.4" + is-generator-function "^1.0.7" + is-typed-array "^1.1.3" + safe-buffer "^5.1.2" + which-typed-array "^1.1.2" + +utils-merge@1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz" + integrity sha1-n5VxD1CiZ5R7LMwSR0HBAoQn5xM= + +uuid@2.0.1: + version "2.0.1" + resolved "https://registry.npmjs.org/uuid/-/uuid-2.0.1.tgz" + integrity sha1-wqMN7bPlNdcsz4LjQ5QaULqFM6w= + +uuid@3.3.2: + version "3.3.2" + resolved "https://registry.npmjs.org/uuid/-/uuid-3.3.2.tgz" + integrity sha512-yXJmeNaw3DnnKAOKJE51sL/ZaYfWJRl1pK9dr19YFCu0ObS231AB1/LbqTKRAQ5kw8A90rA6fr4riOUpTZvQZA== + +uuid@^3.3.2: + version "3.4.0" + resolved "https://registry.npmjs.org/uuid/-/uuid-3.4.0.tgz" + integrity sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A== + +uuid@^8.3.2: + version "8.3.2" + resolved "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz" + integrity sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg== + +v8-compile-cache-lib@^3.0.0: + version "3.0.1" + resolved "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz" + integrity sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg== + +v8-compile-cache@^2.0.3: + version "2.3.0" + resolved "https://registry.npmjs.org/v8-compile-cache/-/v8-compile-cache-2.3.0.tgz" + integrity sha512-l8lCEmLcLYZh4nbunNZvQCJc5pv7+RCwa8q/LdUx8u7lsWvPDKmpodJAJNwkAhJC//dFY48KuIEmjtd4RViDrA== + +validate-npm-package-license@^3.0.1: + version "3.0.4" + resolved "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz" + integrity sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew== + dependencies: + spdx-correct "^3.0.0" + spdx-expression-parse "^3.0.0" + +varint@^5.0.0: + version "5.0.2" + resolved "https://registry.npmjs.org/varint/-/varint-5.0.2.tgz" + integrity sha512-lKxKYG6H03yCZUpAGOPOsMcGxd1RHCu1iKvEHYDPmTyq2HueGhD73ssNBqqQWfvYs04G9iUFRvmAVLW20Jw6ow== + +vary@^1, vary@~1.1.2: + version "1.1.2" + resolved "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz" + integrity sha1-IpnwLG3tMNSllhsLn3RSShj2NPw= + +verror@1.10.0: + version "1.10.0" + resolved "https://registry.npmjs.org/verror/-/verror-1.10.0.tgz" + integrity sha1-OhBcoXBTr1XW4nDB+CiGguGNpAA= + dependencies: + assert-plus "^1.0.0" + core-util-is "1.0.2" + extsprintf "^1.2.0" + +web-streams-polyfill@^3.0.3: + version "3.2.1" + resolved "https://registry.npmjs.org/web-streams-polyfill/-/web-streams-polyfill-3.2.1.tgz" + integrity sha512-e0MO3wdXWKrLbL0DgGnUV7WHVuw9OUvL4hjgnPkIeEvESk74gAITi5G606JtZPp39cd8HA9VQzCIvA49LpPN5Q== + +web3-bzz@1.2.11: + version "1.2.11" + resolved "https://registry.npmjs.org/web3-bzz/-/web3-bzz-1.2.11.tgz" + integrity sha512-XGpWUEElGypBjeFyUhTkiPXFbDVD6Nr/S5jznE3t8cWUA0FxRf1n3n/NuIZeb0H9RkN2Ctd/jNma/k8XGa3YKg== + dependencies: + "@types/node" "^12.12.6" + got "9.6.0" + swarm-js "^0.1.40" + underscore "1.9.1" + +web3-bzz@1.5.3: + version "1.5.3" + resolved "https://registry.npmjs.org/web3-bzz/-/web3-bzz-1.5.3.tgz" + integrity sha512-SlIkAqG0eS6cBS9Q2eBOTI1XFzqh83RqGJWnyrNZMDxUwsTVHL+zNnaPShVPvrWQA1Ub5b0bx1Kc5+qJVxsTJg== + dependencies: + "@types/node" "^12.12.6" + got "9.6.0" + swarm-js "^0.1.40" + +web3-core-helpers@1.2.11: + version "1.2.11" + resolved "https://registry.npmjs.org/web3-core-helpers/-/web3-core-helpers-1.2.11.tgz" + integrity sha512-PEPoAoZd5ME7UfbnCZBdzIerpe74GEvlwT4AjOmHeCVZoIFk7EqvOZDejJHt+feJA6kMVTdd0xzRNN295UhC1A== + dependencies: + underscore "1.9.1" + web3-eth-iban "1.2.11" + web3-utils "1.2.11" + +web3-core-helpers@1.5.3: + version "1.5.3" + resolved "https://registry.npmjs.org/web3-core-helpers/-/web3-core-helpers-1.5.3.tgz" + integrity sha512-Ip1IjB3S8vN7Kf1PPjK41U5gskmMk6IJQlxIVuS8/1U7n/o0jC8krqtpRwiMfAgYyw3TXwBFtxSRTvJtnLyXZw== + dependencies: + web3-eth-iban "1.5.3" + web3-utils "1.5.3" + +web3-core-method@1.2.11: + version "1.2.11" + resolved "https://registry.npmjs.org/web3-core-method/-/web3-core-method-1.2.11.tgz" + integrity sha512-ff0q76Cde94HAxLDZ6DbdmKniYCQVtvuaYh+rtOUMB6kssa5FX0q3vPmixi7NPooFnbKmmZCM6NvXg4IreTPIw== + dependencies: + "@ethersproject/transactions" "^5.0.0-beta.135" + underscore "1.9.1" + web3-core-helpers "1.2.11" + web3-core-promievent "1.2.11" + web3-core-subscriptions "1.2.11" + web3-utils "1.2.11" + +web3-core-method@1.5.3: + version "1.5.3" + resolved "https://registry.npmjs.org/web3-core-method/-/web3-core-method-1.5.3.tgz" + integrity sha512-8wJrwQ2qD9ibWieF9oHXwrJsUGrv3XAtEkNeyvyNMpktNTIjxJ2jaFGQUuLiyUrMubD18XXgLk4JS6PJU4Loeg== + dependencies: + "@ethereumjs/common" "^2.4.0" + "@ethersproject/transactions" "^5.0.0-beta.135" + web3-core-helpers "1.5.3" + web3-core-promievent "1.5.3" + web3-core-subscriptions "1.5.3" + web3-utils "1.5.3" + +web3-core-promievent@1.2.11: + version "1.2.11" + resolved "https://registry.npmjs.org/web3-core-promievent/-/web3-core-promievent-1.2.11.tgz" + integrity sha512-il4McoDa/Ox9Agh4kyfQ8Ak/9ABYpnF8poBLL33R/EnxLsJOGQG2nZhkJa3I067hocrPSjEdlPt/0bHXsln4qA== + dependencies: + eventemitter3 "4.0.4" + +web3-core-promievent@1.5.3: + version "1.5.3" + resolved "https://registry.npmjs.org/web3-core-promievent/-/web3-core-promievent-1.5.3.tgz" + integrity sha512-CFfgqvk3Vk6PIAxtLLuX+pOMozxkKCY+/GdGr7weMh033mDXEPvwyVjoSRO1PqIKj668/hMGQsVoIgbyxkJ9Mg== + dependencies: + eventemitter3 "4.0.4" + +web3-core-requestmanager@1.2.11: + version "1.2.11" + resolved "https://registry.npmjs.org/web3-core-requestmanager/-/web3-core-requestmanager-1.2.11.tgz" + integrity sha512-oFhBtLfOiIbmfl6T6gYjjj9igOvtyxJ+fjS+byRxiwFJyJ5BQOz4/9/17gWR1Cq74paTlI7vDGxYfuvfE/mKvA== + dependencies: + underscore "1.9.1" + web3-core-helpers "1.2.11" + web3-providers-http "1.2.11" + web3-providers-ipc "1.2.11" + web3-providers-ws "1.2.11" + +web3-core-requestmanager@1.5.3: + version "1.5.3" + resolved "https://registry.npmjs.org/web3-core-requestmanager/-/web3-core-requestmanager-1.5.3.tgz" + integrity sha512-9k/Bze2rs8ONix5IZR+hYdMNQv+ark2Ek2kVcrFgWO+LdLgZui/rn8FikPunjE+ub7x7pJaKCgVRbYFXjo3ZWg== + dependencies: + util "^0.12.0" + web3-core-helpers "1.5.3" + web3-providers-http "1.5.3" + web3-providers-ipc "1.5.3" + web3-providers-ws "1.5.3" + +web3-core-subscriptions@1.2.11: + version "1.2.11" + resolved "https://registry.npmjs.org/web3-core-subscriptions/-/web3-core-subscriptions-1.2.11.tgz" + integrity sha512-qEF/OVqkCvQ7MPs1JylIZCZkin0aKK9lDxpAtQ1F8niEDGFqn7DT8E/vzbIa0GsOjL2fZjDhWJsaW+BSoAW1gg== + dependencies: + eventemitter3 "4.0.4" + underscore "1.9.1" + web3-core-helpers "1.2.11" + +web3-core-subscriptions@1.5.3: + version "1.5.3" + resolved "https://registry.npmjs.org/web3-core-subscriptions/-/web3-core-subscriptions-1.5.3.tgz" + integrity sha512-L2m9vG1iRN6thvmv/HQwO2YLhOQlmZU8dpLG6GSo9FBN14Uch868Swk0dYVr3rFSYjZ/GETevSXU+O+vhCummA== + dependencies: + eventemitter3 "4.0.4" + web3-core-helpers "1.5.3" + +web3-core@1.2.11: + version "1.2.11" + resolved "https://registry.npmjs.org/web3-core/-/web3-core-1.2.11.tgz" + integrity sha512-CN7MEYOY5ryo5iVleIWRE3a3cZqVaLlIbIzDPsvQRUfzYnvzZQRZBm9Mq+ttDi2STOOzc1MKylspz/o3yq/LjQ== + dependencies: + "@types/bn.js" "^4.11.5" + "@types/node" "^12.12.6" + bignumber.js "^9.0.0" + web3-core-helpers "1.2.11" + web3-core-method "1.2.11" + web3-core-requestmanager "1.2.11" + web3-utils "1.2.11" + +web3-core@1.5.3: + version "1.5.3" + resolved "https://registry.npmjs.org/web3-core/-/web3-core-1.5.3.tgz" + integrity sha512-ACTbu8COCu+0eUNmd9pG7Q9EVsNkAg2w3Y7SqhDr+zjTgbSHZV01jXKlapm9z+G3AN/BziV3zGwudClJ4u4xXQ== + dependencies: + "@types/bn.js" "^4.11.5" + "@types/node" "^12.12.6" + bignumber.js "^9.0.0" + web3-core-helpers "1.5.3" + web3-core-method "1.5.3" + web3-core-requestmanager "1.5.3" + web3-utils "1.5.3" + +web3-eth-abi@1.2.11: + version "1.2.11" + resolved "https://registry.npmjs.org/web3-eth-abi/-/web3-eth-abi-1.2.11.tgz" + integrity sha512-PkRYc0+MjuLSgg03QVWqWlQivJqRwKItKtEpRUaxUAeLE7i/uU39gmzm2keHGcQXo3POXAbOnMqkDvOep89Crg== + dependencies: + "@ethersproject/abi" "5.0.0-beta.153" + underscore "1.9.1" + web3-utils "1.2.11" + +web3-eth-abi@1.5.3: + version "1.5.3" + resolved "https://registry.npmjs.org/web3-eth-abi/-/web3-eth-abi-1.5.3.tgz" + integrity sha512-i/qhuFsoNrnV130CSRYX/z4SlCfSQ4mHntti5yTmmQpt70xZKYZ57BsU0R29ueSQ9/P+aQrL2t2rqkQkAloUxg== + dependencies: + "@ethersproject/abi" "5.0.7" + web3-utils "1.5.3" + +web3-eth-accounts@1.2.11: + version "1.2.11" + resolved "https://registry.npmjs.org/web3-eth-accounts/-/web3-eth-accounts-1.2.11.tgz" + integrity sha512-6FwPqEpCfKIh3nSSGeo3uBm2iFSnFJDfwL3oS9pyegRBXNsGRVpgiW63yhNzL0796StsvjHWwQnQHsZNxWAkGw== + dependencies: + crypto-browserify "3.12.0" + eth-lib "0.2.8" + ethereumjs-common "^1.3.2" + ethereumjs-tx "^2.1.1" + scrypt-js "^3.0.1" + underscore "1.9.1" + uuid "3.3.2" + web3-core "1.2.11" + web3-core-helpers "1.2.11" + web3-core-method "1.2.11" + web3-utils "1.2.11" + +web3-eth-accounts@1.5.3: + version "1.5.3" + resolved "https://registry.npmjs.org/web3-eth-accounts/-/web3-eth-accounts-1.5.3.tgz" + integrity sha512-pdGhXgeBaEJENMvRT6W9cmji3Zz/46ugFSvmnLLw79qi5EH7XJhKISNVb41eWCrs4am5GhI67GLx5d2s2a72iw== + dependencies: + "@ethereumjs/common" "^2.3.0" + "@ethereumjs/tx" "^3.2.1" + crypto-browserify "3.12.0" + eth-lib "0.2.8" + ethereumjs-util "^7.0.10" + scrypt-js "^3.0.1" + uuid "3.3.2" + web3-core "1.5.3" + web3-core-helpers "1.5.3" + web3-core-method "1.5.3" + web3-utils "1.5.3" + +web3-eth-contract@1.2.11: + version "1.2.11" + resolved "https://registry.npmjs.org/web3-eth-contract/-/web3-eth-contract-1.2.11.tgz" + integrity sha512-MzYuI/Rq2o6gn7vCGcnQgco63isPNK5lMAan2E51AJLknjSLnOxwNY3gM8BcKoy4Z+v5Dv00a03Xuk78JowFow== + dependencies: + "@types/bn.js" "^4.11.5" + underscore "1.9.1" + web3-core "1.2.11" + web3-core-helpers "1.2.11" + web3-core-method "1.2.11" + web3-core-promievent "1.2.11" + web3-core-subscriptions "1.2.11" + web3-eth-abi "1.2.11" + web3-utils "1.2.11" + +web3-eth-contract@1.5.3: + version "1.5.3" + resolved "https://registry.npmjs.org/web3-eth-contract/-/web3-eth-contract-1.5.3.tgz" + integrity sha512-Gdlt1L6cdHe83k7SdV6xhqCytVtOZkjD0kY/15x441AuuJ4JLubCHuqu69k2Dr3tWifHYVys/vG8QE/W16syGg== + dependencies: + "@types/bn.js" "^4.11.5" + web3-core "1.5.3" + web3-core-helpers "1.5.3" + web3-core-method "1.5.3" + web3-core-promievent "1.5.3" + web3-core-subscriptions "1.5.3" + web3-eth-abi "1.5.3" + web3-utils "1.5.3" + +web3-eth-ens@1.2.11: + version "1.2.11" + resolved "https://registry.npmjs.org/web3-eth-ens/-/web3-eth-ens-1.2.11.tgz" + integrity sha512-dbW7dXP6HqT1EAPvnniZVnmw6TmQEKF6/1KgAxbo8iBBYrVTMDGFQUUnZ+C4VETGrwwaqtX4L9d/FrQhZ6SUiA== + dependencies: + content-hash "^2.5.2" + eth-ens-namehash "2.0.8" + underscore "1.9.1" + web3-core "1.2.11" + web3-core-helpers "1.2.11" + web3-core-promievent "1.2.11" + web3-eth-abi "1.2.11" + web3-eth-contract "1.2.11" + web3-utils "1.2.11" + +web3-eth-ens@1.5.3: + version "1.5.3" + resolved "https://registry.npmjs.org/web3-eth-ens/-/web3-eth-ens-1.5.3.tgz" + integrity sha512-QmGFFtTGElg0E+3xfCIFhiUF+1imFi9eg/cdsRMUZU4F1+MZCC/ee+IAelYLfNTGsEslCqfAusliKOT9DdGGnw== + dependencies: + content-hash "^2.5.2" + eth-ens-namehash "2.0.8" + web3-core "1.5.3" + web3-core-helpers "1.5.3" + web3-core-promievent "1.5.3" + web3-eth-abi "1.5.3" + web3-eth-contract "1.5.3" + web3-utils "1.5.3" + +web3-eth-iban@1.2.11: + version "1.2.11" + resolved "https://registry.npmjs.org/web3-eth-iban/-/web3-eth-iban-1.2.11.tgz" + integrity sha512-ozuVlZ5jwFC2hJY4+fH9pIcuH1xP0HEFhtWsR69u9uDIANHLPQQtWYmdj7xQ3p2YT4bQLq/axKhZi7EZVetmxQ== + dependencies: + bn.js "^4.11.9" + web3-utils "1.2.11" + +web3-eth-iban@1.5.3: + version "1.5.3" + resolved "https://registry.npmjs.org/web3-eth-iban/-/web3-eth-iban-1.5.3.tgz" + integrity sha512-vMzmGqolYZvRHwP9P4Nf6G8uYM5aTLlQu2a34vz78p0KlDC+eV1th3+90Qeaupa28EG7OO0IT1F0BejiIauOPw== + dependencies: + bn.js "^4.11.9" + web3-utils "1.5.3" + +web3-eth-personal@1.2.11: + version "1.2.11" + resolved "https://registry.npmjs.org/web3-eth-personal/-/web3-eth-personal-1.2.11.tgz" + integrity sha512-42IzUtKq9iHZ8K9VN0vAI50iSU9tOA1V7XU2BhF/tb7We2iKBVdkley2fg26TxlOcKNEHm7o6HRtiiFsVK4Ifw== + dependencies: + "@types/node" "^12.12.6" + web3-core "1.2.11" + web3-core-helpers "1.2.11" + web3-core-method "1.2.11" + web3-net "1.2.11" + web3-utils "1.2.11" + +web3-eth-personal@1.5.3: + version "1.5.3" + resolved "https://registry.npmjs.org/web3-eth-personal/-/web3-eth-personal-1.5.3.tgz" + integrity sha512-JzibJafR7ak/Icas8uvos3BmUNrZw1vShuNR5Cxjo+vteOC8XMqz1Vr7RH65B4bmlfb3bm9xLxetUHO894+Sew== + dependencies: + "@types/node" "^12.12.6" + web3-core "1.5.3" + web3-core-helpers "1.5.3" + web3-core-method "1.5.3" + web3-net "1.5.3" + web3-utils "1.5.3" + +web3-eth@1.2.11: + version "1.2.11" + resolved "https://registry.npmjs.org/web3-eth/-/web3-eth-1.2.11.tgz" + integrity sha512-REvxW1wJ58AgHPcXPJOL49d1K/dPmuw4LjPLBPStOVkQjzDTVmJEIsiLwn2YeuNDd4pfakBwT8L3bz1G1/wVsQ== + dependencies: + underscore "1.9.1" + web3-core "1.2.11" + web3-core-helpers "1.2.11" + web3-core-method "1.2.11" + web3-core-subscriptions "1.2.11" + web3-eth-abi "1.2.11" + web3-eth-accounts "1.2.11" + web3-eth-contract "1.2.11" + web3-eth-ens "1.2.11" + web3-eth-iban "1.2.11" + web3-eth-personal "1.2.11" + web3-net "1.2.11" + web3-utils "1.2.11" + +web3-eth@1.5.3: + version "1.5.3" + resolved "https://registry.npmjs.org/web3-eth/-/web3-eth-1.5.3.tgz" + integrity sha512-saFurA1L23Bd7MEf7cBli6/jRdMhD4X/NaMiO2mdMMCXlPujoudlIJf+VWpRWJpsbDFdu7XJ2WHkmBYT5R3p1Q== + dependencies: + web3-core "1.5.3" + web3-core-helpers "1.5.3" + web3-core-method "1.5.3" + web3-core-subscriptions "1.5.3" + web3-eth-abi "1.5.3" + web3-eth-accounts "1.5.3" + web3-eth-contract "1.5.3" + web3-eth-ens "1.5.3" + web3-eth-iban "1.5.3" + web3-eth-personal "1.5.3" + web3-net "1.5.3" + web3-utils "1.5.3" + +web3-net@1.2.11: + version "1.2.11" + resolved "https://registry.npmjs.org/web3-net/-/web3-net-1.2.11.tgz" + integrity sha512-sjrSDj0pTfZouR5BSTItCuZ5K/oZPVdVciPQ6981PPPIwJJkCMeVjD7I4zO3qDPCnBjBSbWvVnLdwqUBPtHxyg== + dependencies: + web3-core "1.2.11" + web3-core-method "1.2.11" + web3-utils "1.2.11" + +web3-net@1.5.3: + version "1.5.3" + resolved "https://registry.npmjs.org/web3-net/-/web3-net-1.5.3.tgz" + integrity sha512-0W/xHIPvgVXPSdLu0iZYnpcrgNnhzHMC888uMlGP5+qMCt8VuflUZHy7tYXae9Mzsg1kxaJAS5lHVNyeNw4CoQ== + dependencies: + web3-core "1.5.3" + web3-core-method "1.5.3" + web3-utils "1.5.3" + +web3-provider-engine@14.2.1: + version "14.2.1" + resolved "https://registry.npmjs.org/web3-provider-engine/-/web3-provider-engine-14.2.1.tgz" + integrity sha512-iSv31h2qXkr9vrL6UZDm4leZMc32SjWJFGOp/D92JXfcEboCqraZyuExDkpxKw8ziTufXieNM7LSXNHzszYdJw== + dependencies: + async "^2.5.0" + backoff "^2.5.0" + clone "^2.0.0" + cross-fetch "^2.1.0" + eth-block-tracker "^3.0.0" + eth-json-rpc-infura "^3.1.0" + eth-sig-util "^1.4.2" + ethereumjs-block "^1.2.2" + ethereumjs-tx "^1.2.0" + ethereumjs-util "^5.1.5" + ethereumjs-vm "^2.3.4" + json-rpc-error "^2.0.0" + json-stable-stringify "^1.0.1" + promise-to-callback "^1.0.0" + readable-stream "^2.2.9" + request "^2.85.0" + semaphore "^1.0.3" + ws "^5.1.1" + xhr "^2.2.0" + xtend "^4.0.1" + +web3-providers-http@1.2.11: + version "1.2.11" + resolved "https://registry.npmjs.org/web3-providers-http/-/web3-providers-http-1.2.11.tgz" + integrity sha512-psh4hYGb1+ijWywfwpB2cvvOIMISlR44F/rJtYkRmQ5jMvG4FOCPlQJPiHQZo+2cc3HbktvvSJzIhkWQJdmvrA== + dependencies: + web3-core-helpers "1.2.11" + xhr2-cookies "1.1.0" + +web3-providers-http@1.5.3: + version "1.5.3" + resolved "https://registry.npmjs.org/web3-providers-http/-/web3-providers-http-1.5.3.tgz" + integrity sha512-5DpUyWGHtDAr2RYmBu34Fu+4gJuBAuNx2POeiJIooUtJ+Mu6pIx4XkONWH6V+Ez87tZAVAsFOkJRTYuzMr3rPw== + dependencies: + web3-core-helpers "1.5.3" + xhr2-cookies "1.1.0" + +web3-providers-ipc@1.2.11: + version "1.2.11" + resolved "https://registry.npmjs.org/web3-providers-ipc/-/web3-providers-ipc-1.2.11.tgz" + integrity sha512-yhc7Y/k8hBV/KlELxynWjJDzmgDEDjIjBzXK+e0rHBsYEhdCNdIH5Psa456c+l0qTEU2YzycF8VAjYpWfPnBpQ== + dependencies: + oboe "2.1.4" + underscore "1.9.1" + web3-core-helpers "1.2.11" + +web3-providers-ipc@1.5.3: + version "1.5.3" + resolved "https://registry.npmjs.org/web3-providers-ipc/-/web3-providers-ipc-1.5.3.tgz" + integrity sha512-JmeAptugVpmXI39LGxUSAymx0NOFdgpuI1hGQfIhbEAcd4sv7fhfd5D+ZU4oLHbRI8IFr4qfGU0uhR8BXhDzlg== + dependencies: + oboe "2.1.5" + web3-core-helpers "1.5.3" + +web3-providers-ws@1.2.11: + version "1.2.11" + resolved "https://registry.npmjs.org/web3-providers-ws/-/web3-providers-ws-1.2.11.tgz" + integrity sha512-ZxnjIY1Er8Ty+cE4migzr43zA/+72AF1myzsLaU5eVgdsfV7Jqx7Dix1hbevNZDKFlSoEyq/3j/jYalh3So1Zg== + dependencies: + eventemitter3 "4.0.4" + underscore "1.9.1" + web3-core-helpers "1.2.11" + websocket "^1.0.31" + +web3-providers-ws@1.5.3: + version "1.5.3" + resolved "https://registry.npmjs.org/web3-providers-ws/-/web3-providers-ws-1.5.3.tgz" + integrity sha512-6DhTw4Q7nm5CFYEUHOJM0gAb3xFx+9gWpVveg3YxJ/ybR1BUvEWo3bLgIJJtX56cYX0WyY6DS35a7f0LOI1kVg== + dependencies: + eventemitter3 "4.0.4" + web3-core-helpers "1.5.3" + websocket "^1.0.32" + +web3-shh@1.2.11: + version "1.2.11" + resolved "https://registry.npmjs.org/web3-shh/-/web3-shh-1.2.11.tgz" + integrity sha512-B3OrO3oG1L+bv3E1sTwCx66injW1A8hhwpknDUbV+sw3fehFazA06z9SGXUefuFI1kVs4q2vRi0n4oCcI4dZDg== + dependencies: + web3-core "1.2.11" + web3-core-method "1.2.11" + web3-core-subscriptions "1.2.11" + web3-net "1.2.11" + +web3-shh@1.5.3: + version "1.5.3" + resolved "https://registry.npmjs.org/web3-shh/-/web3-shh-1.5.3.tgz" + integrity sha512-COfEXfsqoV/BkcsNLRxQqnWc1Teb8/9GxdGag5GtPC5gQC/vsN+7hYVJUwNxY9LtJPKYTij2DHHnx6UkITng+Q== + dependencies: + web3-core "1.5.3" + web3-core-method "1.5.3" + web3-core-subscriptions "1.5.3" + web3-net "1.5.3" + +web3-utils@1.2.11: + version "1.2.11" + resolved "https://registry.npmjs.org/web3-utils/-/web3-utils-1.2.11.tgz" + integrity sha512-3Tq09izhD+ThqHEaWYX4VOT7dNPdZiO+c/1QMA0s5X2lDFKK/xHJb7cyTRRVzN2LvlHbR7baS1tmQhSua51TcQ== + dependencies: + bn.js "^4.11.9" + eth-lib "0.2.8" + ethereum-bloom-filters "^1.0.6" + ethjs-unit "0.1.6" + number-to-bn "1.7.0" + randombytes "^2.1.0" + underscore "1.9.1" + utf8 "3.0.0" + +web3-utils@1.5.3: + version "1.5.3" + resolved "https://registry.npmjs.org/web3-utils/-/web3-utils-1.5.3.tgz" + integrity sha512-56nRgA+Ad9SEyCv39g36rTcr5fpsd4L9LgV3FK0aB66nAMazLAA6Qz4lH5XrUKPDyBIPGJIR+kJsyRtwcu2q1Q== + dependencies: + bn.js "^4.11.9" + eth-lib "0.2.8" + ethereum-bloom-filters "^1.0.6" + ethjs-unit "0.1.6" + number-to-bn "1.7.0" + randombytes "^2.1.0" + utf8 "3.0.0" + +web3-utils@^1.0.0-beta.31, web3-utils@^1.3.0: + version "1.7.3" + resolved "https://registry.npmjs.org/web3-utils/-/web3-utils-1.7.3.tgz" + integrity sha512-g6nQgvb/bUpVUIxJE+ezVN+rYwYmlFyMvMIRSuqpi1dk6ApDD00YNArrk7sPcZnjvxOJ76813Xs2vIN2rgh4lg== + dependencies: + bn.js "^4.11.9" + ethereum-bloom-filters "^1.0.6" + ethereumjs-util "^7.1.0" + ethjs-unit "0.1.6" + number-to-bn "1.7.0" + randombytes "^2.1.0" + utf8 "3.0.0" + +web3@1.2.11: + version "1.2.11" + resolved "https://registry.npmjs.org/web3/-/web3-1.2.11.tgz" + integrity sha512-mjQ8HeU41G6hgOYm1pmeH0mRAeNKJGnJEUzDMoerkpw7QUQT4exVREgF1MYPvL/z6vAshOXei25LE/t/Bxl8yQ== + dependencies: + web3-bzz "1.2.11" + web3-core "1.2.11" + web3-eth "1.2.11" + web3-eth-personal "1.2.11" + web3-net "1.2.11" + web3-shh "1.2.11" + web3-utils "1.2.11" + +web3@1.5.3: + version "1.5.3" + resolved "https://registry.npmjs.org/web3/-/web3-1.5.3.tgz" + integrity sha512-eyBg/1K44flfv0hPjXfKvNwcUfIVDI4NX48qHQe6wd7C8nPSdbWqo9vLy6ksZIt9NLa90HjI8HsGYgnMSUxn6w== + dependencies: + web3-bzz "1.5.3" + web3-core "1.5.3" + web3-eth "1.5.3" + web3-eth-personal "1.5.3" + web3-net "1.5.3" + web3-shh "1.5.3" + web3-utils "1.5.3" + +websocket@1.0.32, websocket@^1.0.31: + version "1.0.32" + resolved "https://registry.npmjs.org/websocket/-/websocket-1.0.32.tgz" + integrity sha512-i4yhcllSP4wrpoPMU2N0TQ/q0O94LRG/eUQjEAamRltjQ1oT1PFFKOG4i877OlJgCG8rw6LrrowJp+TYCEWF7Q== + dependencies: + bufferutil "^4.0.1" + debug "^2.2.0" + es5-ext "^0.10.50" + typedarray-to-buffer "^3.1.5" + utf-8-validate "^5.0.2" + yaeti "^0.0.6" + +websocket@^1.0.32: + version "1.0.34" + resolved "https://registry.npmjs.org/websocket/-/websocket-1.0.34.tgz" + integrity sha512-PRDso2sGwF6kM75QykIesBijKSVceR6jL2G8NGYyq2XrItNC2P5/qL5XeR056GhA+Ly7JMFvJb9I312mJfmqnQ== + dependencies: + bufferutil "^4.0.1" + debug "^2.2.0" + es5-ext "^0.10.50" + typedarray-to-buffer "^3.1.5" + utf-8-validate "^5.0.2" + yaeti "^0.0.6" + +which-boxed-primitive@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz" + integrity sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg== + dependencies: + is-bigint "^1.0.1" + is-boolean-object "^1.1.0" + is-number-object "^1.0.4" + is-string "^1.0.5" + is-symbol "^1.0.3" + +which-module@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/which-module/-/which-module-1.0.0.tgz" + integrity sha1-u6Y8qGGUiZT/MHc2CJ47lgJsKk8= + +which-module@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/which-module/-/which-module-2.0.0.tgz" + integrity sha1-2e8H3Od7mQK4o6j6SzHD4/fm6Ho= + +which-typed-array@^1.1.2: + version "1.1.7" + resolved "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.7.tgz" + integrity sha512-vjxaB4nfDqwKI0ws7wZpxIlde1XrLX5uB0ZjpfshgmapJMD7jJWhZI+yToJTqaFByF0eNBcYxbjmCzoRP7CfEw== + dependencies: + available-typed-arrays "^1.0.5" + call-bind "^1.0.2" + es-abstract "^1.18.5" + foreach "^2.0.5" + has-tostringtag "^1.0.0" + is-typed-array "^1.1.7" + +which@1.3.1, which@^1.1.1, which@^1.2.9, which@^1.3.1: + version "1.3.1" + resolved "https://registry.npmjs.org/which/-/which-1.3.1.tgz" + integrity sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ== + dependencies: + isexe "^2.0.0" + +which@2.0.2, which@^2.0.1: + version "2.0.2" + resolved "https://registry.npmjs.org/which/-/which-2.0.2.tgz" + integrity sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA== + dependencies: + isexe "^2.0.0" + +wide-align@1.1.3: + version "1.1.3" + resolved "https://registry.npmjs.org/wide-align/-/wide-align-1.1.3.tgz" + integrity sha512-QGkOQc8XL6Bt5PwnsExKBPuMKBxnGxWWW3fU55Xt4feHozMUhdUMaBCk290qpm/wG5u/RSKzwdAC4i51YigihA== + dependencies: + string-width "^1.0.2 || 2" + +window-size@^0.2.0: + version "0.2.0" + resolved "https://registry.npmjs.org/window-size/-/window-size-0.2.0.tgz" + integrity sha1-tDFbtCFKPXBY6+7okuE/ok2YsHU= + +word-wrap@^1.2.3, word-wrap@~1.2.3: + version "1.2.3" + resolved "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.3.tgz" + integrity sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ== + +wordwrap@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz" + integrity sha1-J1hIEIkUVqQXHI0CJkQa3pDLyus= + +wordwrapjs@^4.0.0: + version "4.0.1" + resolved "https://registry.npmjs.org/wordwrapjs/-/wordwrapjs-4.0.1.tgz" + integrity sha512-kKlNACbvHrkpIw6oPeYDSmdCTu2hdMHoyXLTcUKala++lx5Y+wjJ/e474Jqv5abnVmwxw08DiTuHmw69lJGksA== + dependencies: + reduce-flatten "^2.0.0" + typical "^5.2.0" + +workerpool@6.2.0: + version "6.2.0" + resolved "https://registry.npmjs.org/workerpool/-/workerpool-6.2.0.tgz" + integrity sha512-Rsk5qQHJ9eowMH28Jwhe8HEbmdYDX4lwoMWshiCXugjtHqMD9ZbiqSDLxcsfdqsETPzVUtX5s1Z5kStiIM6l4A== + +wrap-ansi@^2.0.0: + version "2.1.0" + resolved "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-2.1.0.tgz" + integrity sha1-2Pw9KE3QV5T+hJc8rs3Rz4JP3YU= + dependencies: + string-width "^1.0.1" + strip-ansi "^3.0.1" + +wrap-ansi@^5.1.0: + version "5.1.0" + resolved "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-5.1.0.tgz" + integrity sha512-QC1/iN/2/RPVJ5jYK8BGttj5z83LmSKmvbvrXPNCLZSEb32KKVDJDl/MOt2N01qU2H/FkzEa9PKto1BqDjtd7Q== + dependencies: + ansi-styles "^3.2.0" + string-width "^3.0.0" + strip-ansi "^5.0.0" + +wrap-ansi@^6.2.0: + version "6.2.0" + resolved "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-6.2.0.tgz" + integrity sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA== + dependencies: + ansi-styles "^4.0.0" + string-width "^4.1.0" + strip-ansi "^6.0.0" + +wrap-ansi@^7.0.0: + version "7.0.0" + resolved "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz" + integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q== + dependencies: + ansi-styles "^4.0.0" + string-width "^4.1.0" + strip-ansi "^6.0.0" + +wrappy@1: + version "1.0.2" + resolved "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz" + integrity sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8= + +write@1.0.3: + version "1.0.3" + resolved "https://registry.npmjs.org/write/-/write-1.0.3.tgz" + integrity sha512-/lg70HAjtkUgWPVZhZcm+T4hkL8Zbtp1nFNOn3lRrxnlv50SRBv7cR7RqR+GMsd3hUXy9hWBo4CHTbFTcOYwig== + dependencies: + mkdirp "^0.5.1" + +ws@7.4.6: + version "7.4.6" + resolved "https://registry.npmjs.org/ws/-/ws-7.4.6.tgz" + integrity sha512-YmhHDO4MzaDLB+M9ym/mDA5z0naX8j7SIlT8f8z+I0VtzsRbekxEutHSme7NPS2qE8StCYQNUnfWdXta/Yu85A== + +ws@^3.0.0: + version "3.3.3" + resolved "https://registry.npmjs.org/ws/-/ws-3.3.3.tgz" + integrity sha512-nnWLa/NwZSt4KQJu51MYlCcSQ5g7INpOrOMt4XV8j4dqTXdmlUmSHQ8/oLC069ckre0fRsgfvsKwbTdtKLCDkA== + dependencies: + async-limiter "~1.0.0" + safe-buffer "~5.1.0" + ultron "~1.1.0" + +ws@^5.1.1: + version "5.2.3" + resolved "https://registry.yarnpkg.com/ws/-/ws-5.2.3.tgz#05541053414921bc29c63bee14b8b0dd50b07b3d" + integrity sha512-jZArVERrMsKUatIdnLzqvcfydI85dvd/Fp1u/VOpfdDWQ4c9qWXe+VIeAbQ5FrDwciAkr+lzofXLz3Kuf26AOA== + dependencies: + async-limiter "~1.0.0" + +ws@^7.4.6: + version "7.5.7" + resolved "https://registry.npmjs.org/ws/-/ws-7.5.7.tgz" + integrity sha512-KMvVuFzpKBuiIXW3E4u3mySRO2/mCHSyZDJQM5NQ9Q9KHWHWh0NHgfbRMLLrceUK5qAL4ytALJbpRMjixFZh8A== + +xhr-request-promise@^0.1.2: + version "0.1.3" + resolved "https://registry.npmjs.org/xhr-request-promise/-/xhr-request-promise-0.1.3.tgz" + integrity sha512-YUBytBsuwgitWtdRzXDDkWAXzhdGB8bYm0sSzMPZT7Z2MBjMSTHFsyCT1yCRATY+XC69DUrQraRAEgcoCRaIPg== + dependencies: + xhr-request "^1.1.0" + +xhr-request@^1.0.1, xhr-request@^1.1.0: + version "1.1.0" + resolved "https://registry.npmjs.org/xhr-request/-/xhr-request-1.1.0.tgz" + integrity sha512-Y7qzEaR3FDtL3fP30k9wO/e+FBnBByZeybKOhASsGP30NIkRAAkKD/sCnLvgEfAIEC1rcmK7YG8f4oEnIrrWzA== + dependencies: + buffer-to-arraybuffer "^0.0.5" + object-assign "^4.1.1" + query-string "^5.0.1" + simple-get "^2.7.0" + timed-out "^4.0.1" + url-set-query "^1.0.0" + xhr "^2.0.4" + +xhr2-cookies@1.1.0: + version "1.1.0" + resolved "https://registry.npmjs.org/xhr2-cookies/-/xhr2-cookies-1.1.0.tgz" + integrity sha1-fXdEnQmZGX8VXLc7I99yUF7YnUg= + dependencies: + cookiejar "^2.1.1" + +xhr@^2.0.4, xhr@^2.2.0, xhr@^2.3.3: + version "2.6.0" + resolved "https://registry.npmjs.org/xhr/-/xhr-2.6.0.tgz" + integrity sha512-/eCGLb5rxjx5e3mF1A7s+pLlR6CGyqWN91fv1JgER5mVWg1MZmlhBvy9kjcsOdRk8RrIujotWyJamfyrp+WIcA== + dependencies: + global "~4.4.0" + is-function "^1.0.1" + parse-headers "^2.0.0" + xtend "^4.0.0" + +xmlhttprequest@1.8.0: + version "1.8.0" + resolved "https://registry.npmjs.org/xmlhttprequest/-/xmlhttprequest-1.8.0.tgz" + integrity sha1-Z/4HXFwk/vOfnWX197f+dRcZaPw= + +xtend@^4.0.0, xtend@^4.0.1, xtend@^4.0.2, xtend@~4.0.0, xtend@~4.0.1: + version "4.0.2" + resolved "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz" + integrity sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ== + +xtend@~2.1.1: + version "2.1.2" + resolved "https://registry.npmjs.org/xtend/-/xtend-2.1.2.tgz" + integrity sha1-bv7MKk2tjmlixJAbM3znuoe10os= + dependencies: + object-keys "~0.4.0" + +y18n@^3.2.1: + version "3.2.2" + resolved "https://registry.npmjs.org/y18n/-/y18n-3.2.2.tgz" + integrity sha512-uGZHXkHnhF0XeeAPgnKfPv1bgKAYyVvmNL1xlKsPYZPaIHxGti2hHqvOCQv71XMsLxu1QjergkqogUnms5D3YQ== + +y18n@^4.0.0: + version "4.0.3" + resolved "https://registry.npmjs.org/y18n/-/y18n-4.0.3.tgz" + integrity sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ== + +y18n@^5.0.5: + version "5.0.8" + resolved "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz" + integrity sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA== + +yaeti@^0.0.6: + version "0.0.6" + resolved "https://registry.npmjs.org/yaeti/-/yaeti-0.0.6.tgz" + integrity sha1-8m9ITXJoTPQr7ft2lwqhYI+/lXc= + +yallist@^3.0.0, yallist@^3.0.2, yallist@^3.1.1: + version "3.1.1" + resolved "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz" + integrity sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g== + +yallist@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz" + integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A== + +yaml@^1.10.2: + version "1.10.2" + resolved "https://registry.npmjs.org/yaml/-/yaml-1.10.2.tgz" + integrity sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg== + +yargs-parser@13.1.2, yargs-parser@20.2.4, yargs-parser@>=5.0.1, yargs-parser@^13.1.2, yargs-parser@^2.4.1, yargs-parser@^20.2.2: + version "21.0.1" + resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-21.0.1.tgz#0267f286c877a4f0f728fceb6f8a3e4cb95c6e35" + integrity sha512-9BK1jFpLzJROCI5TzwZL/TU4gqjK5xiHV/RfWLOahrjAko/e4DJkRDZQXfvqAsiZzzYhgAzbgz6lg48jcm4GLg== + +yargs-unparser@1.6.0: + version "1.6.0" + resolved "https://registry.npmjs.org/yargs-unparser/-/yargs-unparser-1.6.0.tgz" + integrity sha512-W9tKgmSn0DpSatfri0nx52Joq5hVXgeLiqR/5G0sZNDoLZFOr/xjBUDcShCOGNsBnEMNo1KAMBkTej1Hm62HTw== + dependencies: + flat "^4.1.0" + lodash "^4.17.15" + yargs "^13.3.0" + +yargs-unparser@2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/yargs-unparser/-/yargs-unparser-2.0.0.tgz" + integrity sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA== + dependencies: + camelcase "^6.0.0" + decamelize "^4.0.0" + flat "^5.0.2" + is-plain-obj "^2.1.0" + +yargs@13.3.2, yargs@^13.3.0: + version "13.3.2" + resolved "https://registry.npmjs.org/yargs/-/yargs-13.3.2.tgz" + integrity sha512-AX3Zw5iPruN5ie6xGRIDgqkT+ZhnRlZMLMHAs8tg7nRruy2Nb+i5o9bwghAogtM08q1dpr2LVoS8KSTMYpWXUw== + dependencies: + cliui "^5.0.0" + find-up "^3.0.0" + get-caller-file "^2.0.1" + require-directory "^2.1.1" + require-main-filename "^2.0.0" + set-blocking "^2.0.0" + string-width "^3.0.0" + which-module "^2.0.0" + y18n "^4.0.0" + yargs-parser "^13.1.2" + +yargs@16.2.0: + version "16.2.0" + resolved "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz" + integrity sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw== + dependencies: + cliui "^7.0.2" + escalade "^3.1.1" + get-caller-file "^2.0.5" + require-directory "^2.1.1" + string-width "^4.2.0" + y18n "^5.0.5" + yargs-parser "^20.2.2" + +yargs@^4.7.1: + version "4.8.1" + resolved "https://registry.npmjs.org/yargs/-/yargs-4.8.1.tgz" + integrity sha1-wMQpJMpKqmsObaFznfshZDn53cA= + dependencies: + cliui "^3.2.0" + decamelize "^1.1.1" + get-caller-file "^1.0.1" + lodash.assign "^4.0.3" + os-locale "^1.4.0" + read-pkg-up "^1.0.1" + require-directory "^2.1.1" + require-main-filename "^1.0.1" + set-blocking "^2.0.0" + string-width "^1.0.1" + which-module "^1.0.0" + window-size "^0.2.0" + y18n "^3.2.1" + yargs-parser "^2.4.1" + +yn@3.1.1: + version "3.1.1" + resolved "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz" + integrity sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q== + +yocto-queue@^0.1.0: + version "0.1.0" + resolved "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz" + integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q== + +zksync-web3@^0.4.0: + version "0.4.0" + resolved "https://registry.yarnpkg.com/zksync-web3/-/zksync-web3-0.4.0.tgz#9ab3e8648a6ab11d42b649b3458a0383d6c41bab" + integrity sha512-LmrjkQlg2YSR+P0J1NQKtkraCN2ESKfVoMxole3NxesrASQTsk6fR5+ph/8Vucq/Xh8EoAafp07+Q6TavP/TTw==